From 5dc3dd5d3105ede626870d256a06440685603f12 Mon Sep 17 00:00:00 2001
From: Muximize <Muximize@users.noreply.github.com>
Date: Thu, 25 Jan 2024 01:57:15 +0100
Subject: [PATCH 01/11] Remove QuantityValue

---
 .../UnitsNetGen/NumberExtensionsGenerator.cs  |   2 +-
 .../UnitsNetGen/QuantityGenerator.cs          |   6 +-
 .../UnitsNetGen/StaticQuantityGenerator.cs    |   4 +-
 .../AbbreviatedUnitsConverterTests.cs         |  10 -
 .../AbbreviatedUnitsConverter.cs              |   6 +-
 .../UnitsNetBaseJsonConverter.cs              |   8 +-
 UnitsNet.Tests/CustomQuantities/HowMuch.cs    |   2 +-
 UnitsNet.Tests/DummyIQuantity.cs              |   2 +-
 UnitsNet/CustomCode/Quantity.cs               |  30 +-
 UnitsNet/CustomCode/QuantityParser.cs         |   2 +-
 UnitsNet/IQuantity.cs                         |   2 +-
 UnitsNet/IValueQuantity.cs                    |   2 +-
 UnitsNet/QuantityInfoLookup.cs                |   6 +-
 UnitsNet/QuantityValue.cs                     | 340 ------------------
 UnitsNet/UnitConverter.cs                     |  16 +-
 UnitsNet/UnitMath.cs                          |  22 +-
 16 files changed, 36 insertions(+), 424 deletions(-)
 delete mode 100644 UnitsNet/QuantityValue.cs

diff --git a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
index 61749f5f08..0c5f762c04 100644
--- a/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/NumberExtensionsGenerator.cs
@@ -45,7 +45,7 @@ public static class NumberTo{_quantityName}Extensions
                     continue;
 
                 Writer.WL(2, $@"
-/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(UnitsNet.QuantityValue)"" />");
+/// <inheritdoc cref=""{_quantityName}.From{unit.PluralName}(double)"" />");
 
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit.ObsoleteText));
 
diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index 86490605d1..28f2c4cafb 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
@@ -299,7 +299,7 @@ private void GenerateProperties()
         public {_valueType} Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -429,7 +429,7 @@ private void GenerateStaticFactoryMethods()
         /// <exception cref=""ArgumentException"">If value is NaN or Infinity.</exception>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public static {_quantity.Name} From{unit.PluralName}(QuantityValue {valueParamName})
+        public static {_quantity.Name} From{unit.PluralName}(double {valueParamName})
         {{
             {_valueType} value = ({_valueType}) {valueParamName};
             return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName});
@@ -444,7 +444,7 @@ private void GenerateStaticFactoryMethods()
         /// <param name=""value"">Value to convert from.</param>
         /// <param name=""fromUnit"">Unit to convert from.</param>
         /// <returns>{_quantity.Name} unit value.</returns>
-        public static {_quantity.Name} From(QuantityValue value, {_unitEnumName} fromUnit)
+        public static {_quantity.Name} From(double value, {_unitEnumName} fromUnit)
         {{
             return new {_quantity.Name}(({_valueType})value, fromUnit);
         }}
diff --git a/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
index 502437b592..4dc356fd1e 100644
--- a/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/StaticQuantityGenerator.cs
@@ -49,7 +49,7 @@ public partial class Quantity
         /// <param name=""quantityInfo"">The <see cref=""QuantityInfo""/> of the quantity to create.</param>
         /// <param name=""value"">The value to construct the quantity with.</param>
         /// <returns>The created quantity.</returns>
-        public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValue value)
+        public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, double value)
         {
             return quantityInfo.Name switch
             {");
@@ -72,7 +72,7 @@ public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValu
         /// <param name=""unit"">Unit enum value.</param>
         /// <param name=""quantity"">The resulting quantity if successful, otherwise <c>default</c>.</param>
         /// <returns><c>True</c> if successful with <paramref name=""quantity""/> assigned the value, otherwise <c>false</c>.</returns>
-        public static bool TryFrom(QuantityValue value, Enum? unit, [NotNullWhen(true)] out IQuantity? quantity)
+        public static bool TryFrom(double value, Enum? unit, [NotNullWhen(true)] out IQuantity? quantity)
         {
             quantity = unit switch
             {");
diff --git a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
index 10de4f9a3c..e26fb8c26b 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
@@ -342,16 +342,6 @@ class PlainOldDoubleQuantity
             public string Unit { get; set; }
         }
 
-        [Fact]
-        public void LargeDecimalQuantity_DeserializedTo_PlainOldDoubleQuantity()
-        {
-            const string json = """{"Value":18446744073709551614,"Unit":"EB","Type":"Information"}""";
-            var plainOldQuantity = JsonConvert.DeserializeObject<PlainOldDoubleQuantity>(json);
-
-            Assert.Equal(18446744073709551614d, plainOldQuantity.Value);
-            Assert.Equal("EB", plainOldQuantity.Unit);
-        }
-
         #endregion
 
     }
diff --git a/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs b/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
index ba06ab91d8..10618cef25 100644
--- a/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
@@ -172,15 +172,11 @@ protected string GetQuantityType(IQuantity quantity)
                 unit = GetUnitOrDefault(unitAbbreviation, quantityInfo);
             }
 
-            QuantityValue value;
+            double value;
             if (valueToken is null)
             {
                 value = default;
             }
-            else if (quantityInfo.Zero is IValueQuantity<decimal>)
-            {
-                value = decimal.Parse(valueToken, CultureInfo.InvariantCulture);
-            }
             else
             {
                 value = double.Parse(valueToken, CultureInfo.InvariantCulture);
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
index b284f0ebae..8bbfa5770a 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
@@ -21,7 +21,7 @@ public abstract class UnitsNetBaseJsonConverter<T> : JsonConverter<T>
 
         /// <summary>
         /// Register custom types so that the converter can instantiate these quantities.
-        /// Instead of calling <see cref="Quantity.From(UnitsNet.QuantityValue,System.Enum)"/>, the <see cref="Activator"/> will be used to instantiate the object.
+        /// Instead of calling <see cref="Quantity.From(double,System.Enum)"/>, the <see cref="Activator"/> will be used to instantiate the object.
         /// It is therefore assumed that the constructor of <paramref name="quantity"/> is specified with <c>new T(double value, typeof(<paramref name="unit"/>) unit)</c>.
         /// Registering the same <paramref name="unit"/> multiple times, it will overwrite the one registered.
         /// </summary>
@@ -113,11 +113,7 @@ protected IQuantity ConvertValueUnit(ValueUnit valueUnit)
                 return (IQuantity)Activator.CreateInstance(registeredQuantity, valueUnit.Value, unit);
             }
 
-            return valueUnit switch
-            {
-                ExtendedValueUnit {ValueType: "decimal", ValueString: {}} extendedValueUnit => Quantity.From(decimal.Parse(extendedValueUnit.ValueString, CultureInfo.InvariantCulture), unit),
-                _ => Quantity.From(valueUnit.Value, unit)
-            };
+            return Quantity.From(valueUnit.Value, unit);
         }
 
         private (Type? Quantity, Type? Unit) GetRegisteredType(string unit)
diff --git a/UnitsNet.Tests/CustomQuantities/HowMuch.cs b/UnitsNet.Tests/CustomQuantities/HowMuch.cs
index 95456a9877..233c97b1f1 100644
--- a/UnitsNet.Tests/CustomQuantities/HowMuch.cs
+++ b/UnitsNet.Tests/CustomQuantities/HowMuch.cs
@@ -19,7 +19,7 @@ public HowMuch(double value, HowMuchUnit unit)
         Enum IQuantity.Unit => Unit;
         public HowMuchUnit Unit { get; }
 
-        public QuantityValue Value { get; }
+        public double Value { get; }
 
         #region IQuantity
 
diff --git a/UnitsNet.Tests/DummyIQuantity.cs b/UnitsNet.Tests/DummyIQuantity.cs
index 01a39f4eb3..cc15ec1af4 100644
--- a/UnitsNet.Tests/DummyIQuantity.cs
+++ b/UnitsNet.Tests/DummyIQuantity.cs
@@ -13,7 +13,7 @@ internal class DummyIQuantity : IQuantity
 
         public Enum Unit => throw new NotImplementedException();
 
-        public QuantityValue Value => throw new NotImplementedException();
+        public double Value => throw new NotImplementedException();
 
         public double As(Enum unit ) => throw new NotImplementedException();
 
diff --git a/UnitsNet/CustomCode/Quantity.cs b/UnitsNet/CustomCode/Quantity.cs
index 51afc17a5f..8d59082bcf 100644
--- a/UnitsNet/CustomCode/Quantity.cs
+++ b/UnitsNet/CustomCode/Quantity.cs
@@ -46,7 +46,7 @@ public static bool TryGetUnitInfo(Enum unitEnum, [NotNullWhen(true)] out UnitInf
         /// <param name="unit">Unit enum value.</param>
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="UnitNotFoundException">Unit value is not a known unit enum type.</exception>
-        public static IQuantity From(QuantityValue value, Enum unit)
+        public static IQuantity From(double value, Enum unit)
         {
             return TryFrom(value, unit, out IQuantity? quantity)
                 ? quantity
@@ -61,7 +61,7 @@ public static IQuantity From(QuantityValue value, Enum unit)
         /// <param name="unitName">The invariant unit enum name, such as "Meter". Does not support localization.</param>
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="ArgumentException">Unit value is not a known unit enum type.</exception>
-        public static IQuantity From(QuantityValue value, string quantityName, string unitName)
+        public static IQuantity From(double value, string quantityName, string unitName)
         {
             // Get enum value for this unit, f.ex. LengthUnit.Meter for unit name "Meter".
             return UnitConverter.TryParseUnit(quantityName, unitName, out Enum? unitValue) &&
@@ -78,14 +78,14 @@ public static IQuantity From(QuantityValue value, string quantityName, string un
         ///     Unit abbreviation matching is case-insensitive.<br/>
         ///     <br/>
         ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br/>
-        ///     Prefer <see cref="From(UnitsNet.QuantityValue,System.Enum)"/> or <see cref="From(UnitsNet.QuantityValue,string,string)"/> instead.
+        ///     Prefer <see cref="From(double,System.Enum)"/> or <see cref="From(double,string,string)"/> instead.
         /// </remarks>
         /// <param name="value">Numeric value.</param>
         /// <param name="unitAbbreviation">Unit abbreviation, such as "kg" for <see cref="MassUnit.Kilogram"/>.</param>
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="UnitNotFoundException">Unit abbreviation is not known.</exception>
         /// <exception cref="AmbiguousUnitParseException">Multiple units found matching the given unit abbreviation.</exception>
-        public static IQuantity FromUnitAbbreviation(QuantityValue value, string unitAbbreviation) => FromUnitAbbreviation(null, value, unitAbbreviation);
+        public static IQuantity FromUnitAbbreviation(double value, string unitAbbreviation) => FromUnitAbbreviation(null, value, unitAbbreviation);
 
         /// <summary>
         ///     Dynamically construct a quantity from a numeric value and a unit abbreviation.
@@ -95,7 +95,7 @@ public static IQuantity From(QuantityValue value, string quantityName, string un
         ///     Unit abbreviation matching is case-insensitive.<br/>
         ///     <br/>
         ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br/>
-        ///     Prefer <see cref="From(UnitsNet.QuantityValue,System.Enum)"/> or <see cref="From(UnitsNet.QuantityValue,string,string)"/> instead.
+        ///     Prefer <see cref="From(double,System.Enum)"/> or <see cref="From(double,string,string)"/> instead.
         /// </remarks>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="value">Numeric value.</param>
@@ -103,7 +103,7 @@ public static IQuantity From(QuantityValue value, string quantityName, string un
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="UnitNotFoundException">Unit abbreviation is not known.</exception>
         /// <exception cref="AmbiguousUnitParseException">Multiple units found matching the given unit abbreviation.</exception>
-        public static IQuantity FromUnitAbbreviation(IFormatProvider? formatProvider, QuantityValue value, string unitAbbreviation)
+        public static IQuantity FromUnitAbbreviation(IFormatProvider? formatProvider, double value, string unitAbbreviation)
         {
             // TODO Optimize this with UnitValueAbbreviationLookup via UnitAbbreviationsCache.TryGetUnitValueAbbreviationLookup.
             List<Enum> units = GetUnitsForAbbreviation(formatProvider, unitAbbreviation);
@@ -121,16 +121,6 @@ public static IQuantity FromUnitAbbreviation(IFormatProvider? formatProvider, Qu
             return From(value, unit);
         }
 
-        /// <inheritdoc cref="TryFrom(QuantityValue,System.Enum,out UnitsNet.IQuantity)"/>
-        public static bool TryFrom(double value, Enum unit, [NotNullWhen(true)] out IQuantity? quantity)
-        {
-            quantity = default;
-
-            // Implicit cast to QuantityValue would prevent TryFrom from being called,
-            // so we need to explicitly check this here for double arguments.
-            return TryFrom((QuantityValue)value, unit, out quantity);
-        }
-
         /// <summary>
         ///     Try to dynamically construct a quantity from a value, the quantity name and the unit name.
         /// </summary>
@@ -155,14 +145,14 @@ public static bool TryFrom(double value, string quantityName, string unitName, [
         ///     Unit abbreviation matching is case-insensitive.<br/>
         ///     <br/>
         ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br/>
-        ///     Prefer <see cref="From(UnitsNet.QuantityValue,System.Enum)"/> or <see cref="From(UnitsNet.QuantityValue,string,string)"/> instead.
+        ///     Prefer <see cref="From(double,System.Enum)"/> or <see cref="From(double,string,string)"/> instead.
         /// </remarks>
         /// <param name="value">Numeric value.</param>
         /// <param name="unitAbbreviation">Unit abbreviation, such as "kg" for <see cref="MassUnit.Kilogram"/>.</param>
         /// <param name="quantity">The quantity if successful, otherwise null.</param>
         /// <returns>True if successful.</returns>
         /// <exception cref="ArgumentException">Unit value is not a known unit enum type.</exception>
-        public static bool TryFromUnitAbbreviation(QuantityValue value, string unitAbbreviation, [NotNullWhen(true)] out IQuantity? quantity) =>
+        public static bool TryFromUnitAbbreviation(double value, string unitAbbreviation, [NotNullWhen(true)] out IQuantity? quantity) =>
             TryFromUnitAbbreviation(null, value, unitAbbreviation, out quantity);
 
         /// <summary>
@@ -173,7 +163,7 @@ public static bool TryFromUnitAbbreviation(QuantityValue value, string unitAbbre
         ///     Unit abbreviation matching is case-insensitive.<br/>
         ///     <br/>
         ///     This will fail if more than one unit across all quantities share the same unit abbreviation.<br/>
-        ///     Prefer <see cref="From(UnitsNet.QuantityValue,System.Enum)"/> or <see cref="From(UnitsNet.QuantityValue,string,string)"/> instead.
+        ///     Prefer <see cref="From(double,System.Enum)"/> or <see cref="From(double,string,string)"/> instead.
         /// </remarks>
         /// <param name="formatProvider">The format provider to use for lookup. Defaults to <see cref="CultureInfo.CurrentCulture" /> if null.</param>
         /// <param name="value">Numeric value.</param>
@@ -181,7 +171,7 @@ public static bool TryFromUnitAbbreviation(QuantityValue value, string unitAbbre
         /// <param name="quantity">The quantity if successful, otherwise null.</param>
         /// <returns>True if successful.</returns>
         /// <exception cref="ArgumentException">Unit value is not a known unit enum type.</exception>
-        public static bool TryFromUnitAbbreviation(IFormatProvider? formatProvider, QuantityValue value, string unitAbbreviation, [NotNullWhen(true)] out IQuantity? quantity)
+        public static bool TryFromUnitAbbreviation(IFormatProvider? formatProvider, double value, string unitAbbreviation, [NotNullWhen(true)] out IQuantity? quantity)
         {
             // TODO Optimize this with UnitValueAbbreviationLookup via UnitAbbreviationsCache.TryGetUnitValueAbbreviationLookup.
             List<Enum> units = GetUnitsForAbbreviation(formatProvider, unitAbbreviation);
diff --git a/UnitsNet/CustomCode/QuantityParser.cs b/UnitsNet/CustomCode/QuantityParser.cs
index 9e003359e5..dfbea7a01b 100644
--- a/UnitsNet/CustomCode/QuantityParser.cs
+++ b/UnitsNet/CustomCode/QuantityParser.cs
@@ -17,7 +17,7 @@ namespace UnitsNet
     /// </summary>
     /// <typeparam name="TQuantity">The type of quantity to create, such as <see cref="Length"/>.</typeparam>
     /// <typeparam name="TUnitType">The type of unit enum that belongs to this quantity, such as <see cref="LengthUnit"/> for <see cref="Length"/>.</typeparam>
-    public delegate TQuantity QuantityFromDelegate<out TQuantity, in TUnitType>(QuantityValue value, TUnitType fromUnit)
+    public delegate TQuantity QuantityFromDelegate<out TQuantity, in TUnitType>(double value, TUnitType fromUnit)
         where TQuantity : IQuantity
         where TUnitType : Enum;
 
diff --git a/UnitsNet/IQuantity.cs b/UnitsNet/IQuantity.cs
index a67d33d382..0056bbedf5 100644
--- a/UnitsNet/IQuantity.cs
+++ b/UnitsNet/IQuantity.cs
@@ -72,7 +72,7 @@ public interface IQuantity : IFormattable
         /// <summary>
         ///     The value this quantity was constructed with. See also <see cref="Unit"/>.
         /// </summary>
-        QuantityValue Value { get; }
+        double Value { get; }
 
         /// <summary>
         ///     Converts this <see cref="IQuantity"/> to an <see cref="IQuantity"/> in the given <paramref name="unit"/>.
diff --git a/UnitsNet/IValueQuantity.cs b/UnitsNet/IValueQuantity.cs
index 0b458787d1..a660be089a 100644
--- a/UnitsNet/IValueQuantity.cs
+++ b/UnitsNet/IValueQuantity.cs
@@ -10,7 +10,7 @@ namespace UnitsNet
     /// <remarks>
     ///     Currently, only 3 quantities are backed by <see cref="decimal"/>: <see cref="Power"/>, <see cref="BitRate"/> and <see cref="Information"/>.
     ///     <br/><br/>
-    ///     The future of decimal support is uncertain. We may either change everything to double to simplify, or use generics or <see cref="QuantityValue"/>
+    ///     The future of decimal support is uncertain. We may either change everything to double to simplify, or use generics or QuantityValue
     ///     more broadly to better support any value type.
     ///     <br/><br/>
     ///     The <see cref="Power"/> quantity originally introduced decimal due to precision issues with large units and due to the implementation at that
diff --git a/UnitsNet/QuantityInfoLookup.cs b/UnitsNet/QuantityInfoLookup.cs
index 745d322239..386e797cf0 100644
--- a/UnitsNet/QuantityInfoLookup.cs
+++ b/UnitsNet/QuantityInfoLookup.cs
@@ -103,7 +103,7 @@ public void AddUnitInfo(Enum unit, UnitInfo unitInfo)
         /// <param name="unit">Unit enum value.</param>
         /// <returns>An <see cref="IQuantity"/> object.</returns>
         /// <exception cref="ArgumentException">Unit value is not a know unit enum type.</exception>
-        public IQuantity From(QuantityValue value, Enum unit)
+        public IQuantity From(double value, Enum unit)
         {
             // TODO Support custom units, currently only hardcoded built-in quantities are supported.
             return Quantity.TryFrom(value, unit, out IQuantity? quantity)
@@ -111,7 +111,7 @@ public IQuantity From(QuantityValue value, Enum unit)
                 : throw new UnitNotFoundException($"Unit value {unit} of type {unit.GetType()} is not a known unit enum type. Expected types like UnitsNet.Units.LengthUnit. Did you pass in a custom enum type defined outside the UnitsNet library?");
         }
 
-        /// <inheritdoc cref="Quantity.TryFrom(QuantityValue,System.Enum,out UnitsNet.IQuantity)"/>
+        /// <inheritdoc cref="Quantity.TryFrom(double,System.Enum,out UnitsNet.IQuantity)"/>
         public bool TryFrom(double value, Enum unit, [NotNullWhen(true)] out IQuantity? quantity)
         {
             // Implicit cast to QuantityValue would prevent TryFrom from being called,
@@ -123,7 +123,7 @@ public bool TryFrom(double value, Enum unit, [NotNullWhen(true)] out IQuantity?
             }
 
             // TODO Support custom units, currently only hardcoded built-in quantities are supported.
-            return Quantity.TryFrom((QuantityValue)value, unit, out quantity);
+            return Quantity.TryFrom(value, unit, out quantity);
         }
 
         /// <inheritdoc cref="Parse(IFormatProvider, System.Type,string)"/>
diff --git a/UnitsNet/QuantityValue.cs b/UnitsNet/QuantityValue.cs
deleted file mode 100644
index a5ea81418a..0000000000
--- a/UnitsNet/QuantityValue.cs
+++ /dev/null
@@ -1,340 +0,0 @@
-// 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;
-using System.Diagnostics;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Globalization;
-using UnitsNet.InternalHelpers;
-
-namespace UnitsNet
-{
-    /// <summary>
-    ///     A type that supports implicit cast from all .NET numeric types, in order to avoid a large number of overloads
-    ///     and binary size for all From(value, unit) factory methods, for each of the 700+ units in the library.
-    ///     <see cref="QuantityValue"/> stores the value internally with the proper type to preserve the range or precision of the original value:
-    /// <list type="bullet">
-    /// <item><description><see cref="double"/> for [byte, short, int, long, float, double]</description></item>
-    /// <item><description><see cref="decimal"/> for [decimal] to preserve the 128-bit precision</description></item>
-    /// </list>
-    /// </summary>
-    /// <remarks>
-    ///     <para>At the time of this writing, this reduces the number of From(value, unit) overloads to 1/4th:
-    ///     From 8 (int, long, double, decimal + each nullable) down to 2 (QuantityValue and QuantityValue?).
-    ///     This also adds more numeric types with no extra overhead, such as float, short and byte.</para>
-    ///     <para>So far, the internal representation can be either <see cref="double"/> or <see cref="decimal"/>,
-    ///     but as this struct is realized as a union struct with overlapping fields, only the amount of memory of the largest data type is used.
-    ///     This allows for adding support for smaller data types without increasing the overall size.</para>
-    /// </remarks>
-    [StructLayout(LayoutKind.Explicit)]
-    [DebuggerDisplay("{GetDebugRepresentation()}")]
-    public readonly struct QuantityValue : IFormattable, IEquatable<QuantityValue>, IComparable<QuantityValue>, IComparable
-    {
-        /// <summary>
-        /// The value 0
-        /// </summary>
-        public static readonly QuantityValue Zero = new QuantityValue(0, 0);
-
-        /// <summary>
-        ///     Value assigned when implicitly casting from all numeric types except <see cref="decimal" />, since
-        ///     <see cref="double" /> has the greatest range.
-        /// </summary>
-        [FieldOffset(8)] // so that it does not interfere with the Type field
-        private readonly double _doubleValue;
-
-        /// <summary>
-        ///     Value assigned when implicitly casting from <see cref="decimal" /> type, since it has a greater precision than
-        ///     <see cref="double"/> and we want to preserve that when constructing quantities that use <see cref="decimal"/>
-        ///     as their value type.
-        /// </summary>
-        [FieldOffset(0)]
-        // bytes layout: 0-1 unused, 2 exponent, 3 sign (only highest bit), 4-15 number
-        private readonly decimal _decimalValue;
-
-        /// <summary>
-        ///     Determines the underlying type of this <see cref="QuantityValue"/>.
-        /// </summary>
-        [FieldOffset(0)] // using unused byte for storing type
-        public readonly UnderlyingDataType Type;
-
-        private QuantityValue(double val) : this()
-        {
-            _doubleValue = val;
-            Type = UnderlyingDataType.Double;
-        }
-
-        private QuantityValue(decimal val) : this()
-        {
-            _decimalValue = val;
-            Type = UnderlyingDataType.Decimal;
-        }
-
-        private QuantityValue(double value, decimal valueDecimal) : this()
-        {
-            if (valueDecimal != 0)
-            {
-                _decimalValue = valueDecimal;
-                Type = UnderlyingDataType.Decimal;
-            }
-            else
-            {
-                _doubleValue = value;
-                Type = UnderlyingDataType.Double;
-            }
-        }
-
-        /// <summary>
-        /// Returns true if the underlying value is stored as a decimal
-        /// </summary>
-        public bool IsDecimal => Type == UnderlyingDataType.Decimal;
-
-        #region To QuantityValue
-
-        // Prefer double for integer types, since most quantities use that type as of now and
-        // that avoids unnecessary casts back and forth.
-        // If we later change to use decimal more, we should revisit this.
-        /// <summary>Implicit cast from <see cref="byte"/> to <see cref="QuantityValue"/>.</summary>
-        public static implicit operator QuantityValue(byte val) => new QuantityValue((double) val);
-        /// <summary>Implicit cast from <see cref="short"/> to <see cref="QuantityValue"/>.</summary>
-        public static implicit operator QuantityValue(short val) => new QuantityValue((double) val);
-        /// <summary>Implicit cast from <see cref="int"/> to <see cref="QuantityValue"/>.</summary>
-        public static implicit operator QuantityValue(int val) => new QuantityValue((double) val);
-        /// <summary>Implicit cast from <see cref="long"/> to <see cref="QuantityValue"/>.</summary>
-        public static implicit operator QuantityValue(long val) => new QuantityValue((double) val);
-        /// <summary>Implicit cast from <see cref="float"/> to <see cref="QuantityValue"/>.</summary>
-        public static implicit operator QuantityValue(float val) => new QuantityValue(val); // double
-        /// <summary>Implicit cast from <see cref="double"/> to <see cref="QuantityValue"/>.</summary>
-        public static implicit operator QuantityValue(double val) => new QuantityValue(val); // double
-        /// <summary>Implicit cast from <see cref="decimal"/> to <see cref="QuantityValue"/>.</summary>
-        public static implicit operator QuantityValue(decimal val) => new QuantityValue(val); // decimal
-        #endregion
-
-        #region To double
-
-        /// <summary>Explicit cast from <see cref="QuantityValue"/> to <see cref="double"/>.</summary>
-        public static explicit operator double(QuantityValue number)
-            => number.Type switch
-            {
-                UnderlyingDataType.Decimal => (double)number._decimalValue,
-                UnderlyingDataType.Double => number._doubleValue,
-                _ => throw new NotImplementedException()
-            };
-
-        #endregion
-
-        #region To decimal
-
-        /// <summary>Explicit cast from <see cref="QuantityValue"/> to <see cref="decimal"/>.</summary>
-        public static explicit operator decimal(QuantityValue number)
-            => number.Type switch
-        {
-            UnderlyingDataType.Decimal => number._decimalValue,
-            UnderlyingDataType.Double => (decimal)number._doubleValue,
-            _ => throw new NotImplementedException()
-        };
-
-        #endregion
-
-        #region Operators and Comparators
-
-        /// <inheritdoc />
-        public override bool Equals(object? other)
-        {
-            if (other is QuantityValue qv)
-            {
-                return Equals(qv);
-            }
-
-            return false;
-        }
-
-        /// <inheritdoc />
-        public override int GetHashCode()
-        {
-            if (IsDecimal)
-            {
-                return _decimalValue.GetHashCode();
-            }
-            else
-            {
-                return _doubleValue.GetHashCode();
-            }
-        }
-
-        /// <summary>
-        /// Performs an equality comparison on two instances of <see cref="QuantityValue"/>.
-        /// Note that rounding might occur if the two values don't use the same base type.
-        /// </summary>
-        /// <param name="other">The value to compare to</param>
-        /// <returns>True on exact equality, false otherwise</returns>
-        public bool Equals(QuantityValue other)
-        {
-            return CompareTo(other) == 0;
-        }
-
-        /// <summary>Equality comparator</summary>
-        public static bool operator ==(QuantityValue a, QuantityValue b)
-        {
-            return a.CompareTo(b) == 0;
-        }
-
-        /// <summary>Inequality comparator</summary>
-        public static bool operator !=(QuantityValue a, QuantityValue b)
-        {
-            return a.CompareTo(b) != 0;
-        }
-
-        /// <summary>
-        /// Greater-than operator
-        /// </summary>
-        public static bool operator >(QuantityValue a, QuantityValue b)
-        {
-            return a.CompareTo(b) > 0;
-        }
-
-        /// <summary>
-        /// Less-than operator
-        /// </summary>
-        public static bool operator <(QuantityValue a, QuantityValue b)
-        {
-            return a.CompareTo(b) < 0;
-        }
-
-        /// <summary>
-        /// Greater-than-or-equal operator
-        /// </summary>
-        public static bool operator >=(QuantityValue a, QuantityValue b)
-        {
-            return a.CompareTo(b) >= 0;
-        }
-
-        /// <summary>
-        /// Less-than-or-equal operator
-        /// </summary>
-        public static bool operator <=(QuantityValue a, QuantityValue b)
-        {
-            return a.CompareTo(b) <= 0;
-        }
-
-        /// <inheritdoc />
-        public int CompareTo(QuantityValue other)
-        {
-            if (IsDecimal && other.IsDecimal)
-            {
-                return _decimalValue.CompareTo(other._decimalValue);
-            }
-            else if (IsDecimal)
-            {
-                return _decimalValue.CompareTo((decimal)other._doubleValue);
-            }
-            else if (other.IsDecimal)
-            {
-                return ((decimal)_doubleValue).CompareTo(other._decimalValue);
-            }
-            else
-            {
-                return _doubleValue.CompareTo(other._doubleValue);
-            }
-        }
-
-        /// <inheritdoc />
-        public int CompareTo(object? obj)
-        {
-            if (obj is null) throw new ArgumentNullException(nameof(obj));
-            if (!(obj is QuantityValue other)) throw new ArgumentException("Expected type QuantityValue.", nameof(obj));
-
-            return CompareTo(other);
-        }
-
-        /// <summary>
-        /// Returns the negated value of the operand
-        /// </summary>
-        /// <param name="v">Value to negate</param>
-        /// <returns>-v</returns>
-        public static QuantityValue operator -(QuantityValue v)
-        {
-            if (v.IsDecimal)
-            {
-                return new QuantityValue(-v._decimalValue);
-            }
-            else
-            {
-                return new QuantityValue(-v._doubleValue);
-            }
-        }
-
-        #endregion
-
-        /// <summary>Returns the string representation of the numeric value.</summary>
-        public override string ToString()
-            => Type switch
-            {
-                UnderlyingDataType.Decimal => _decimalValue.ToString(CultureInfo.CurrentCulture),
-                UnderlyingDataType.Double => _doubleValue.ToString(CultureInfo.CurrentCulture),
-                _ => throw new NotImplementedException()
-            };
-
-        private string GetDebugRepresentation()
-        {
-            StringBuilder builder = new($"{Type} {ToString()} Hex:");
-
-            byte[] bytes = BytesUtility.GetBytes(this);
-            for (int i = bytes.Length - 1; i >= 0; i--)
-            {
-                builder.Append($" {bytes[i]:X2}");
-            }
-
-            return builder.ToString();
-        }
-
-        /// <summary>
-        /// Returns the string representation of the numeric value, formatted using the given standard numeric format string
-        /// </summary>
-        /// <param name="format">A standard numeric format string (must be valid for either double or decimal, depending on the base type)</param>
-        /// <returns>The string representation</returns>
-        public string ToString(string format)
-        {
-            return ToString(format, CultureInfo.CurrentCulture);
-        }
-
-        /// <summary>
-        /// Returns the string representation of the numeric value, formatted using the given standard numeric format string
-        /// </summary>
-        /// <param name="formatProvider">The culture to use</param>
-        /// <returns>The string representation</returns>
-        public string ToString(IFormatProvider formatProvider)
-        {
-            return ToString(string.Empty, formatProvider);
-        }
-
-        /// <summary>
-        /// Returns the string representation of the underlying value
-        /// </summary>
-        /// <param name="format">Standard format specifiers. Because the underlying value can be double or decimal, the meaning can vary</param>
-        /// <param name="formatProvider">Culture specific settings</param>
-        /// <returns>A string representation of the number</returns>
-        public string ToString(string? format, IFormatProvider? formatProvider)
-        {
-            if (IsDecimal)
-            {
-                return _decimalValue.ToString(format, formatProvider);
-            }
-            else
-            {
-                return _doubleValue.ToString(format, formatProvider);
-            }
-        }
-
-        /// <summary>
-        ///     Describes the underlying type of a <see cref="QuantityValue"/>.
-        /// </summary>
-        public enum UnderlyingDataType : byte
-        {
-            /// <summary><see cref="Decimal"/> must have the value 0 due to the bit structure of <see cref="decimal"/>.</summary>
-            Decimal = 0,
-            /// <inheritdoc cref="double"/>
-            Double = 1
-        }
-    }
-}
diff --git a/UnitsNet/UnitConverter.cs b/UnitsNet/UnitConverter.cs
index af16bbe001..4f030b422b 100644
--- a/UnitsNet/UnitConverter.cs
+++ b/UnitsNet/UnitConverter.cs
@@ -278,7 +278,7 @@ public bool TryGetConversionFunction(ConversionFunctionLookupKey lookupKey, [Not
         /// <param name="fromUnitValue">From unit enum value.</param>
         /// <param name="toUnitValue">To unit enum value, must be compatible with <paramref name="fromUnitValue" />.</param>
         /// <returns>The converted value in the new unit representation.</returns>
-        public static double Convert(QuantityValue fromValue, Enum fromUnitValue, Enum toUnitValue)
+        public static double Convert(double fromValue, Enum fromUnitValue, Enum toUnitValue)
         {
             return Quantity
                 .From(fromValue, fromUnitValue)
@@ -293,7 +293,7 @@ public static double Convert(QuantityValue fromValue, Enum fromUnitValue, Enum t
         /// <param name="toUnitValue">To unit enum value, must be compatible with <paramref name="fromUnitValue" />.</param>
         /// <param name="convertedValue">The converted value, if successful. Otherwise default.</param>
         /// <returns>True if successful.</returns>
-        public static bool TryConvert(QuantityValue fromValue, Enum fromUnitValue, Enum toUnitValue, out double convertedValue)
+        public static bool TryConvert(double fromValue, Enum fromUnitValue, Enum toUnitValue, out double convertedValue)
         {
             convertedValue = 0;
             if (!Quantity.TryFrom(fromValue, fromUnitValue, out IQuantity? fromQuantity))
@@ -330,7 +330,7 @@ public static bool TryConvert(QuantityValue fromValue, Enum fromUnitValue, Enum
         /// <returns>Output value as the result of converting to <paramref name="toUnit" />.</returns>
         /// <exception cref="UnitNotFoundException">No units match the abbreviation.</exception>
         /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        public static double ConvertByName(QuantityValue fromValue, string quantityName, string fromUnit, string toUnit)
+        public static double ConvertByName(double fromValue, string quantityName, string fromUnit, string toUnit)
         {
             if (!TryParseUnit(quantityName, toUnit, out Enum? toUnitValue)) // ex: LengthUnit.Centimeter
             {
@@ -358,7 +358,7 @@ public static double ConvertByName(QuantityValue fromValue, string quantityName,
         /// <param name="result">Result if conversion was successful, 0 if not.</param>
         /// <example>bool ok = TryConvertByName(5, "Length", "Meter", "Centimeter", out double centimeters); // 500</example>
         /// <returns>True if conversion was successful.</returns>
-        public static bool TryConvertByName(QuantityValue inputValue, string quantityName, string fromUnit, string toUnit, out double result)
+        public static bool TryConvertByName(double inputValue, string quantityName, string fromUnit, string toUnit, out double result)
         {
             result = 0d;
 
@@ -395,7 +395,7 @@ public static bool TryConvertByName(QuantityValue inputValue, string quantityNam
         /// <param name="toUnitAbbrev">The abbreviation of the unit in the thread's current culture, such as "m".</param>
         /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
         /// <returns>Output value as the result of converting to <paramref name="toUnitAbbrev" />.</returns>
-        public static double ConvertByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev)
+        public static double ConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev)
         {
             return ConvertByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, null);
         }
@@ -423,7 +423,7 @@ public static double ConvertByAbbreviation(QuantityValue fromValue, string quant
         ///     are mapped to the abbreviation.
         /// </exception>
         /// <exception cref="AmbiguousUnitParseException">More than one unit matches the abbreviation.</exception>
-        public static double ConvertByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, string? culture)
+        public static double ConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, string? culture)
         {
             if (!TryGetUnitType(quantityName, out Type? unitType))
                 throw new UnitNotFoundException($"The unit type for the given quantity was not found: {quantityName}");
@@ -455,7 +455,7 @@ public static double ConvertByAbbreviation(QuantityValue fromValue, string quant
         /// <param name="result">Result if conversion was successful, 0 if not.</param>
         /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
         /// <returns>True if conversion was successful.</returns>
-        public static bool TryConvertByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out double result)
+        public static bool TryConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out double result)
         {
             return TryConvertByAbbreviation(fromValue, quantityName, fromUnitAbbrev, toUnitAbbrev, out result, null);
         }
@@ -479,7 +479,7 @@ public static bool TryConvertByAbbreviation(QuantityValue fromValue, string quan
         /// <param name="result">Result if conversion was successful, 0 if not.</param>
         /// <example>double centimeters = ConvertByName(5, "Length", "m", "cm"); // 500</example>
         /// <returns>True if conversion was successful.</returns>
-        public static bool TryConvertByAbbreviation(QuantityValue fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out double result,
+        public static bool TryConvertByAbbreviation(double fromValue, string quantityName, string fromUnitAbbrev, string toUnitAbbrev, out double result,
             string? culture)
         {
             result = 0d;
diff --git a/UnitsNet/UnitMath.cs b/UnitsNet/UnitMath.cs
index f9ab87d1c8..a38184033d 100644
--- a/UnitsNet/UnitMath.cs
+++ b/UnitsNet/UnitMath.cs
@@ -17,7 +17,7 @@ public static class UnitMath
         /// <returns>A quantity with a value, such that 0 ≤ value ≤ <see cref="F:System.Double.MaxValue" />.</returns>
         public static TQuantity Abs<TQuantity>(this TQuantity value) where TQuantity : IQuantity
         {
-            return value.Value >= QuantityValue.Zero ? value : (TQuantity) Quantity.From(-value.Value, value.Unit);
+            return value.Value >= 0.0 ? value : (TQuantity) Quantity.From(-value.Value, value.Unit);
         }
 
         /// <summary>Computes the sum of a sequence of <typeparamref name="TQuantity" /> values.</summary>
@@ -238,25 +238,5 @@ public static TQuantity Clamp<TQuantity>(TQuantity value, TQuantity min, TQuanti
 
             return value;
         }
-
-        /// <summary>
-        /// Explicitly create a <see cref="QuantityValue"/> instance from a double
-        /// </summary>
-        /// <param name="value">The input value</param>
-        /// <returns>An instance of <see cref="QuantityValue"/></returns>
-        public static QuantityValue ToQuantityValue(this double value)
-        {
-            return value; // Implicit cast
-        }
-
-        /// <summary>
-        /// Explicitly create a <see cref="QuantityValue"/> instance from a decimal
-        /// </summary>
-        /// <param name="value">The input value</param>
-        /// <returns>An instance of <see cref="QuantityValue"/></returns>
-        public static QuantityValue ToQuantityValue(this decimal value)
-        {
-            return value; // Implicit cast
-        }
     }
 }

From 911b480f5ac6bab301517d0b2ce658d596ab0711 Mon Sep 17 00:00:00 2001
From: Muximize <Muximize@users.noreply.github.com>
Date: Sat, 27 Jan 2024 00:14:39 +0100
Subject: [PATCH 02/11] Remove IValueQuantity

---
 .../UnitsNetGen/QuantityGenerator.cs          | 21 ------
 .../UnitsNetGen/UnitTestBaseClassGenerator.cs |  5 +-
 .../AbbreviatedUnitsConverter.cs              | 10 +--
 .../UnitsNetBaseJsonConverter.cs              | 12 ----
 UnitsNet.Tests/IValueQuantityTests.cs         | 47 ------------
 UnitsNet/IQuantity.cs                         |  2 +-
 UnitsNet/IValueQuantity.cs                    | 71 -------------------
 7 files changed, 3 insertions(+), 165 deletions(-)
 delete mode 100644 UnitsNet.Tests/IValueQuantityTests.cs
 delete mode 100644 UnitsNet/IValueQuantity.cs

diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index 28f2c4cafb..7ce1b611e7 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
@@ -1068,15 +1068,6 @@ double IQuantity.As(Enum unit)
             return (double)As(typedUnit);
         }}
 
-        /// <inheritdoc />
-        {_quantity.ValueType} IValueQuantity<{_quantity.ValueType}>.As(Enum unit)
-        {{
-            if (!(unit is {_unitEnumName} typedUnit))
-                throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
-
-            return As(typedUnit);
-        }}
-
         /// <summary>
         ///     Converts this {_quantity.Name} to another {_quantity.Name} with the unit representation <paramref name=""unit"" />.
         /// </summary>
@@ -1206,18 +1197,6 @@ IQuantity IQuantity.ToUnit(Enum unit)
         /// <inheritdoc />
         IQuantity<{_unitEnumName}> IQuantity<{_unitEnumName}>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<{_quantity.ValueType}> IValueQuantity<{_quantity.ValueType}>.ToUnit(Enum unit)
-        {{
-            if (unit is not {_unitEnumName} typedUnit)
-                throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }}
-
-        /// <inheritdoc />
-        IValueQuantity<{_quantity.ValueType}> IValueQuantity<{_quantity.ValueType}>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 ");
         }
diff --git a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
index 1c39c9824f..5579d69895 100644
--- a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
@@ -162,10 +162,7 @@ public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
         public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
         {{
             var quantity = new {_quantity.Name}();
-            Assert.Equal(0, quantity.Value);");
-            if (_quantity.ValueType == "decimal") Writer.WL(@"
-            Assert.Equal(0m, ((IValueQuantity<decimal>)quantity).Value);");
-            Writer.WL($@"
+            Assert.Equal(0, quantity.Value);
             Assert.Equal({_baseUnitFullName}, quantity.Unit);
         }}
 ");
diff --git a/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs b/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
index 10618cef25..1eafb78ba5 100644
--- a/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/AbbreviatedUnitsConverter.cs
@@ -79,15 +79,7 @@ public override void WriteJson(JsonWriter writer, IQuantity? quantity, JsonSeria
 
             // write the 'Value' using the actual type
             writer.WritePropertyName(ValueProperty);
-            if (quantity is IValueQuantity<decimal> decimalQuantity)
-            {
-                // cannot use `writer.WriteValue(decimalQuantity.Value)`: there is a hidden EnsureDecimalPlace(..) method call inside it that converts '123' to '123.0'
-                writer.WriteRawValue(decimalQuantity.Value.ToString(CultureInfo.InvariantCulture));
-            }
-            else
-            {
-                writer.WriteValue((double)quantity.Value);
-            }
+            writer.WriteValue((double)quantity.Value);
 
             //  write the 'Unit' abbreviation
             writer.WritePropertyName(UnitProperty);
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
index 8bbfa5770a..9dae845683 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
@@ -178,18 +178,6 @@ protected ValueUnit ConvertIQuantity(IQuantity quantity)
         {
             quantity = quantity ?? throw new ArgumentNullException(nameof(quantity));
 
-            if (quantity is IValueQuantity<decimal> d)
-            {
-                return new ExtendedValueUnit
-                {
-                    Unit = $"{quantity.QuantityInfo.UnitType.Name}.{quantity.Unit}",
-                    // The type of "Value" is still double
-                    Value = (double)quantity.Value,
-                    ValueString = d.Value.ToString(CultureInfo.InvariantCulture),
-                    ValueType = "decimal"
-                };
-            }
-
             return new ValueUnit {Value = (double)quantity.Value, Unit = $"{quantity.QuantityInfo.UnitType.Name}.{quantity.Unit}"};
         }
 
diff --git a/UnitsNet.Tests/IValueQuantityTests.cs b/UnitsNet.Tests/IValueQuantityTests.cs
deleted file mode 100644
index ae8783c87b..0000000000
--- a/UnitsNet.Tests/IValueQuantityTests.cs
+++ /dev/null
@@ -1,47 +0,0 @@
-// 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.Units;
-using Xunit;
-
-namespace UnitsNet.Tests
-{
-    // ReSharper disable once InconsistentNaming
-    public class IValueQuantityTests
-    {
-        [Fact]
-        public void IValueQuantityTDouble_Value_ReturnsDouble()
-        {
-            IValueQuantity<double> doubleQuantity = Temperature.FromDegreesCelsius(1234.5);
-            Assert.IsType<double>(doubleQuantity.Value);
-        }
-
-        [Fact]
-        public void IValueQuantityTDouble_AsEnum_ReturnsDouble()
-        {
-            IValueQuantity<double> doubleQuantity = Temperature.FromDegreesCelsius(1234.5);
-            Assert.IsType<double>(doubleQuantity.As(TemperatureUnit.Kelvin));
-        }
-
-        [Fact]
-        public void IValueQuantityTDouble_AsUnitSystem_ReturnsDouble()
-        {
-            IValueQuantity<double> doubleQuantity = Temperature.FromDegreesCelsius(1234.5);
-            Assert.IsType<double>(doubleQuantity.As(UnitSystem.SI));
-        }
-
-        [Fact]
-        public void IValueQuantityTDouble_ToUnitEnum_ReturnsIValueQuantityTDouble()
-        {
-            IValueQuantity<double> doubleQuantity = Temperature.FromDegreesCelsius(1234.5);
-            Assert.IsAssignableFrom<IValueQuantity<double>>(doubleQuantity.ToUnit(TemperatureUnit.Kelvin));
-        }
-
-        [Fact]
-        public void IValueQuantityTDouble_ToUnitUnitSystem_ReturnsIValueQuantityTDouble()
-        {
-            IValueQuantity<double> doubleQuantity = Temperature.FromDegreesCelsius(1234.5);
-            Assert.IsAssignableFrom<IValueQuantity<double>>(doubleQuantity.ToUnit(UnitSystem.SI));
-        }
-    }
-}
diff --git a/UnitsNet/IQuantity.cs b/UnitsNet/IQuantity.cs
index 0056bbedf5..680f353863 100644
--- a/UnitsNet/IQuantity.cs
+++ b/UnitsNet/IQuantity.cs
@@ -148,7 +148,7 @@ public interface IQuantity<TUnitType> : IQuantity
     /// </summary>
     /// <typeparam name="TUnitType">The unit type of the quantity.</typeparam>
     /// <typeparam name="TValueType">The value type of the quantity.</typeparam>
-    public interface IQuantity<TUnitType, out TValueType> : IQuantity<TUnitType>, IValueQuantity<TValueType>
+    public interface IQuantity<TUnitType, out TValueType> : IQuantity<TUnitType>
         where TUnitType : Enum
 #if NET7_0_OR_GREATER
         where TValueType : INumber<TValueType>
diff --git a/UnitsNet/IValueQuantity.cs b/UnitsNet/IValueQuantity.cs
deleted file mode 100644
index a660be089a..0000000000
--- a/UnitsNet/IValueQuantity.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using System;
-using System.Numerics;
-using UnitsNet.Units;
-
-namespace UnitsNet
-{
-    /// <summary>
-    ///     Represents a quantity backed by a particular value type, such as <see cref="double"/> or <see cref="decimal"/>.
-    /// </summary>
-    /// <remarks>
-    ///     Currently, only 3 quantities are backed by <see cref="decimal"/>: <see cref="Power"/>, <see cref="BitRate"/> and <see cref="Information"/>.
-    ///     <br/><br/>
-    ///     The future of decimal support is uncertain. We may either change everything to double to simplify, or use generics or QuantityValue
-    ///     more broadly to better support any value type.
-    ///     <br/><br/>
-    ///     The <see cref="Power"/> quantity originally introduced decimal due to precision issues with large units and due to the implementation at that
-    ///     time storing the value in the base unit. This is no longer as big of a problem after changing to unit-value representation, since you typically
-    ///     convert to similar sized units. There is also the option of specifying conversion functions directly between any 2 units to further improve precision.
-    ///     <br/><br/>
-    ///     <see cref="BitRate"/>/<see cref="Information"/>, however, do map more naturally to decimal, since its smallest unit <see cref="InformationUnit.Bit"/> is an integer value,
-    ///     similar to 100ns ticks as the smallest unit in <see cref="DateTime"/> and <see cref="TimeSpan"/>.
-    /// </remarks>
-    /// <typeparam name="TValueType">The value type of the quantity.</typeparam>
-    public interface IValueQuantity<out TValueType> : IQuantity
-#if NET7_0_OR_GREATER
-        where TValueType : INumber<TValueType>
-#else
-        where TValueType : struct
-#endif
-    {
-        /// <summary>
-        ///     The value this quantity was constructed with. See also <see cref="IQuantity.Unit"/>.
-        /// </summary>
-        new TValueType Value { get; }
-
-        /// <summary>
-        ///     Gets the value in the given unit.
-        /// </summary>
-        /// <param name="unit">The unit enum value. The unit must be compatible, so for <see cref="Length"/> you should provide a <see cref="LengthUnit"/> value.</param>
-        /// <returns>Value converted to the specified unit.</returns>
-        /// <exception cref="InvalidCastException">Wrong unit enum type was given.</exception>
-        new TValueType As(Enum unit);
-
-        /// <summary>
-        ///     Gets the value in the unit determined by the given <see cref="UnitSystem"/>. If multiple units were found for the given <see cref="UnitSystem"/>,
-        ///     the first match will be used.
-        /// </summary>
-        /// <param name="unitSystem">The <see cref="UnitSystem"/> to convert the quantity value to.</param>
-        /// <returns>The converted value.</returns>
-        new TValueType As(UnitSystem unitSystem);
-
-        /// <summary>
-        ///     Converts this <see cref="IValueQuantity{TValueType}"/> to an <see cref="IValueQuantity{TValueType}"/> in the given <paramref name="unit"/>.
-        /// </summary>
-        /// <param name="unit">
-        ///     The unit <see cref="Enum"/> value. The <see cref="Enum"/> must be compatible with the units of the <see cref="IValueQuantity{TValueType}"/>.
-        ///     For example, if the <see cref="IValueQuantity{TValueType}"/> is a <see cref="Length"/>, you should provide a <see cref="LengthUnit"/> value.
-        /// </param>
-        /// <exception cref="NotImplementedException">Conversion was not possible from this <see cref="IValueQuantity{TValueType}"/> to <paramref name="unit"/>.</exception>
-        /// <returns>A new <see cref="IValueQuantity{TValueType}"/> in the given <paramref name="unit"/>.</returns>
-        new IValueQuantity<TValueType> ToUnit(Enum unit);
-
-        /// <summary>
-        ///     Converts to a quantity with a unit determined by the given <see cref="UnitSystem"/>, which affects things like <see cref="IQuantity.ToString(System.IFormatProvider)"/>.
-        ///     If multiple units were found for the given <see cref="UnitSystem"/>, the first match will be used.
-        /// </summary>
-        /// <param name="unitSystem">The <see cref="UnitSystem"/> to convert the quantity to.</param>
-        /// <returns>A new <see cref="IValueQuantity{TValueType}"/> with the determined unit.</returns>
-        new IValueQuantity<TValueType> ToUnit(UnitSystem unitSystem);
-    }
-}

From f9474990b9943112ba164711a6a7defa5f86e25b Mon Sep 17 00:00:00 2001
From: Muximize <Muximize@users.noreply.github.com>
Date: Sat, 27 Jan 2024 00:32:41 +0100
Subject: [PATCH 03/11] Remove TValueType from IQuantity

---
 .../UnitsNetGen/QuantityGenerator.cs          |  2 +-
 UnitsNet.Tests/CustomCode/IQuantityTests.cs   | 22 -----------
 UnitsNet.Tests/QuantityTests.cs               | 12 +++---
 UnitsNet/IArithmeticQuantity.cs               | 15 +++-----
 UnitsNet/IQuantity.cs                         | 37 +++----------------
 5 files changed, 17 insertions(+), 71 deletions(-)

diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index 7ce1b611e7..8f9fa6fa1d 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
@@ -69,7 +69,7 @@ namespace UnitsNet
             Writer.WL(@$"
     [DataContract]
     public readonly partial struct {_quantity.Name} :
-        {(_quantity.GenerateArithmetic ? "IArithmeticQuantity" : "IQuantity")}<{_quantity.Name}, {_unitEnumName}, {_quantity.ValueType}>,");
+        {(_quantity.GenerateArithmetic ? "IArithmeticQuantity" : "IQuantity")}<{_quantity.Name}, {_unitEnumName}>,");
 
             if (_quantity.Relations.Any(r => r.Operator is "*" or "/"))
             {
diff --git a/UnitsNet.Tests/CustomCode/IQuantityTests.cs b/UnitsNet.Tests/CustomCode/IQuantityTests.cs
index 6333011d83..1193a838fa 100644
--- a/UnitsNet.Tests/CustomCode/IQuantityTests.cs
+++ b/UnitsNet.Tests/CustomCode/IQuantityTests.cs
@@ -57,27 +57,5 @@ public void ToUnit_GivenSIUnitSystem_ReturnsSIQuantity()
             Assert.Equal(0.0508, inSI.Value);
             Assert.Equal(LengthUnit.Meter, inSI.Unit);
         }
-
-
-        [Fact]
-        public void IQuantityTUnitDouble_Value_ReturnsDouble()
-        {
-            IQuantity<TemperatureUnit, double> doubleQuantity = Temperature.FromDegreesCelsius(1234.5);
-            Assert.IsType<double>(doubleQuantity.Value);
-        }
-
-        [Fact]
-        public void IQuantityTUnitDouble_AsEnum_ReturnsDouble()
-        {
-            IQuantity<TemperatureUnit, double> doubleQuantity = Temperature.FromDegreesCelsius(1234.5);
-            Assert.IsType<double>(doubleQuantity.As(TemperatureUnit.Kelvin));
-        }
-
-        [Fact]
-        public void IQuantityTUnitDouble_AsUnitSystem_ReturnsDouble()
-        {
-            IQuantity<TemperatureUnit, double> doubleQuantity = Temperature.FromDegreesCelsius(1234.5);
-            Assert.IsType<double>(doubleQuantity.As(UnitSystem.SI));
-        }
     }
 }
diff --git a/UnitsNet.Tests/QuantityTests.cs b/UnitsNet.Tests/QuantityTests.cs
index eac72fb99a..555153121c 100644
--- a/UnitsNet.Tests/QuantityTests.cs
+++ b/UnitsNet.Tests/QuantityTests.cs
@@ -31,9 +31,9 @@ public void GetHashCodeForDifferentQuantitiesWithSameValuesAreNotEqual()
         public void Equals_IGenericEquatableQuantity(string q1String, string q2String, string toleranceString, bool expectedEqual)
         {
             // This interfaces implements .NET generic math interfaces.
-            IQuantity<Length, LengthUnit, double> q1 = ParseLength(q1String);
-            IQuantity<Length, LengthUnit, double> q2 = ParseLength(q2String);
-            IQuantity<Length, LengthUnit, double> tolerance = ParseLength(toleranceString);
+            IQuantity<Length, LengthUnit> q1 = ParseLength(q1String);
+            IQuantity<Length, LengthUnit> q2 = ParseLength(q2String);
+            IQuantity<Length, LengthUnit> tolerance = ParseLength(toleranceString);
 
             Assert.Equal(expectedEqual, q1.Equals(q2, tolerance));
         }
@@ -88,9 +88,9 @@ public void Equals_IQuantity_ToleranceIsDifferentType_Throws()
         [Fact]
         public void Equals_GenericEquatableIQuantity_OtherIsNull_ReturnsFalse()
         {
-            IQuantity<Length, LengthUnit, double> q1 = ParseLength("10 m");
-            IQuantity<Length, LengthUnit, double>? q2 = null;
-            IQuantity<Length, LengthUnit, double> tolerance = ParseLength("0.1 m");
+            IQuantity<Length, LengthUnit> q1 = ParseLength("10 m");
+            IQuantity<Length, LengthUnit>? q2 = null;
+            IQuantity<Length, LengthUnit> tolerance = ParseLength("0.1 m");
 
             Assert.False(q1.Equals(q2, tolerance));
         }
diff --git a/UnitsNet/IArithmeticQuantity.cs b/UnitsNet/IArithmeticQuantity.cs
index 7e9ce19b06..031a4510e0 100644
--- a/UnitsNet/IArithmeticQuantity.cs
+++ b/UnitsNet/IArithmeticQuantity.cs
@@ -7,26 +7,21 @@
 namespace UnitsNet;
 
 /// <summary>
-///     An <see cref="IQuantity{TSelf, TUnitType, TValueType}"/> that (in .NET 7+) implements generic math interfaces for arithmetic operations.
+///     An <see cref="IQuantity{TSelf, TUnitType}"/> that (in .NET 7+) implements generic math interfaces for arithmetic operations.
 /// </summary>
 /// <typeparam name="TSelf">The type itself, for the CRT pattern.</typeparam>
 /// <typeparam name="TUnitType">The underlying unit enum type.</typeparam>
-/// <typeparam name="TValueType">The underlying value type for internal representation.</typeparam>
-public interface IArithmeticQuantity<TSelf, TUnitType, TValueType> : IQuantity<TSelf, TUnitType, TValueType>
+public interface IArithmeticQuantity<TSelf, TUnitType> : IQuantity<TSelf, TUnitType>
 #if NET7_0_OR_GREATER
     , IAdditionOperators<TSelf, TSelf, TSelf>
     , IAdditiveIdentity<TSelf, TSelf>
     , ISubtractionOperators<TSelf, TSelf, TSelf>
-    , IMultiplyOperators<TSelf, TValueType, TSelf>
-    , IDivisionOperators<TSelf, TValueType, TSelf>
+    , IMultiplyOperators<TSelf, double, TSelf>
+    , IDivisionOperators<TSelf, double, TSelf>
     , IUnaryNegationOperators<TSelf, TSelf>
 #endif
-    where TSelf : IArithmeticQuantity<TSelf, TUnitType, TValueType>
+    where TSelf : IArithmeticQuantity<TSelf, TUnitType>
     where TUnitType : Enum
-    where TValueType : struct
-#if NET7_0_OR_GREATER
-    , INumber<TValueType>
-#endif
 {
 #if NET7_0_OR_GREATER
     /// <summary>
diff --git a/UnitsNet/IQuantity.cs b/UnitsNet/IQuantity.cs
index 680f353863..c3ff8b17d6 100644
--- a/UnitsNet/IQuantity.cs
+++ b/UnitsNet/IQuantity.cs
@@ -142,49 +142,22 @@ public interface IQuantity<TUnitType> : IQuantity
         new IQuantity<TUnitType> ToUnit(UnitSystem unitSystem);
     }
 
-    /// <summary>
-    ///     A quantity backed by a particular value type with a stronger typed interface where the unit enum type is known, to avoid passing in the
-    ///     wrong unit enum type and not having to cast from <see cref="Enum"/>.
-    /// </summary>
-    /// <typeparam name="TUnitType">The unit type of the quantity.</typeparam>
-    /// <typeparam name="TValueType">The value type of the quantity.</typeparam>
-    public interface IQuantity<TUnitType, out TValueType> : IQuantity<TUnitType>
-        where TUnitType : Enum
-#if NET7_0_OR_GREATER
-        where TValueType : INumber<TValueType>
-#else
-        where TValueType : struct
-#endif
-    {
-        /// <summary>
-        ///     Convert to a unit representation <typeparamref name="TUnitType"/>.
-        /// </summary>
-        /// <returns>Value converted to the specified unit.</returns>
-        new TValueType As(TUnitType unit);
-    }
-
     /// <summary>
     ///     An <see cref="IQuantity{TUnitType}"/> that (in .NET 7+) implements generic math interfaces for equality, comparison and parsing.
     /// </summary>
     /// <typeparam name="TSelf">The type itself, for the CRT pattern.</typeparam>
     /// <typeparam name="TUnitType">The underlying unit enum type.</typeparam>
-    /// <typeparam name="TValueType">The underlying value type for internal representation.</typeparam>
 #if NET7_0_OR_GREATER
-    public interface IQuantity<TSelf, TUnitType, out TValueType>
-        : IQuantity<TUnitType, TValueType>
+    public interface IQuantity<TSelf, TUnitType>
+        : IQuantity<TUnitType>
         , IComparisonOperators<TSelf, TSelf, bool>
         , IParsable<TSelf>
 #else
-    public interface IQuantity<in TSelf, TUnitType, out TValueType>
-        : IQuantity<TUnitType, TValueType>
+    public interface IQuantity<in TSelf, TUnitType>
+        : IQuantity<TUnitType>
 #endif
-        where TSelf : IQuantity<TSelf, TUnitType, TValueType>
+        where TSelf : IQuantity<TSelf, TUnitType>
         where TUnitType : Enum
-#if NET7_0_OR_GREATER
-        where TValueType : INumber<TValueType>
-#else
-        where TValueType : struct
-#endif
     {
         /// <summary>
         ///     <para>

From 4594e50b00b6539c4cbc729aa4c7da9fddf4e163 Mon Sep 17 00:00:00 2001
From: Muximize <Muximize@users.noreply.github.com>
Date: Sat, 27 Jan 2024 01:16:34 +0100
Subject: [PATCH 04/11] Remove decimal support from Serialization

---
 .../AbbreviatedUnitsConverterTests.cs         | 110 ---------------
 .../UnitsNetBaseJsonConverterTest.cs          | 131 ------------------
 .../UnitsNetBaseJsonConverter.cs              |  46 +-----
 3 files changed, 3 insertions(+), 284 deletions(-)

diff --git a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
index e26fb8c26b..5324f9a071 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/AbbreviatedUnitsConverterTests.cs
@@ -221,116 +221,6 @@ public void DoubleZeroBaseQuantity_DeserializedFromEmptyInput()
             Assert.Equal(Mass.BaseUnit, quantity.Unit);
         }
 
-        [Fact]
-        public void DecimalIQuantity_DeserializedFromDecimalValueAndAbbreviatedUnit()
-        {
-            var json = """{"Value":1.200,"Unit":"EB","Type":"Information"}""";
-
-            var quantity = (Information) DeserializeObject<IQuantity>(json);
-
-            Assert.Equal(1.200, quantity.Value);
-            Assert.Equal(InformationUnit.Exabyte, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalQuantity_DeserializedFromDecimalValueAndAbbreviatedUnit()
-        {
-            var json = """{"Value":1.200,"Unit":"EB"}""";
-
-            var quantity = DeserializeObject<Information>(json);
-
-            Assert.Equal(1.200, quantity.Value);
-            Assert.Equal(InformationUnit.Exabyte, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalIQuantity_DeserializedFromQuotedDecimalValueAndAbbreviatedUnit()
-        {
-            var json = """{"Value":"1.200","Unit":"EB","Type":"Information"}""";
-
-            var quantity = (Information) DeserializeObject<IQuantity>(json);
-
-            Assert.Equal(1.200, quantity.Value);
-            Assert.Equal(InformationUnit.Exabyte, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalQuantity_DeserializedFromQuotedDecimalValueAndAbbreviatedUnit()
-        {
-            var json = """{"Value":"1.200","Unit":"EB"}""";
-
-            var quantity = DeserializeObject<Information>(json);
-
-            Assert.Equal(1.200, quantity.Value);
-            Assert.Equal(InformationUnit.Exabyte, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalZeroIQuantity_DeserializedFromAbbreviatedUnitAndNoValue()
-        {
-            var json = """{"Unit":"EB","Type":"Information"}""";
-
-            var quantity = (Information)DeserializeObject<IQuantity>(json);
-
-            Assert.Equal(0, quantity.Value);
-            Assert.Equal(InformationUnit.Exabyte, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalZeroQuantity_DeserializedFromAbbreviatedUnitAndNoValue()
-        {
-            var json = """{"Unit":"EB"}""";
-
-            var quantity = DeserializeObject<Information>(json);
-
-            Assert.Equal(0, quantity.Value);
-            Assert.Equal(InformationUnit.Exabyte, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalBaseUnitIQuantity_DeserializedFromDecimalValueAndNoUnit()
-        {
-            var json = """{"Value":1.200,"Type":"Information"}""";
-
-            var quantity = (Information)DeserializeObject<IQuantity>(json);
-
-            Assert.Equal(1.200, quantity.Value);
-            Assert.Equal(Information.BaseUnit, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalBaseUnitQuantity_DeserializedFromDecimalValueAndNoUnit()
-        {
-            var json = """{"Value":1.200}""";
-
-            var quantity = DeserializeObject<Information>(json);
-
-            Assert.Equal(1.200, quantity.Value);
-            Assert.Equal(Information.BaseUnit, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalZeroBaseIQuantity_DeserializedFromQuantityTypeOnly()
-        {
-            var json = """{"Type":"Information"}""";
-
-            var quantity = (Information)DeserializeObject<IQuantity>(json);
-
-            Assert.Equal(0, quantity.Value);
-            Assert.Equal(Information.BaseUnit, quantity.Unit);
-        }
-
-        [Fact]
-        public void DecimalZeroBaseQuantity_DeserializedFromEmptyInput()
-        {
-            var json = "{}";
-
-            var quantity = DeserializeObject<Information>(json);
-
-            Assert.Equal(0, quantity.Value);
-            Assert.Equal(Information.BaseUnit, quantity.Unit);
-        }
-
         #endregion
 
         #region Compatibility
diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
index ceb4481ec9..112f65de2a 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
@@ -3,7 +3,6 @@
 
 using System;
 using System.Collections.Generic;
-using System.Globalization;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Converters;
 using Newtonsoft.Json.Linq;
@@ -38,16 +37,6 @@ public void UnitsNetBaseJsonConverter_ConvertIQuantity_throws_ArgumentNullExcept
             Assert.Equal("Value cannot be null. (Parameter 'quantity')", result.Message);
         }
 
-        [Fact]
-        public void UnitsNetBaseJsonConverter_ConvertValueUnit_works_as_expected()
-        {
-            var result = _sut.Test_ConvertDecimalValueUnit("PowerUnit.Watt", 10.2365m);
-
-            Assert.NotNull(result);
-            Assert.IsType<Power>(result);
-            Assert.True(Power.FromWatts(10.2365).Equals((Power)result, 1e-5, ComparisonType.Absolute));
-        }
-
         [Fact]
         public void UnitsNetBaseJsonConverter_ConvertValueUnit_throws_UnitsNetException_when_unit_does_not_exist()
         {
@@ -58,16 +47,6 @@ public void UnitsNetBaseJsonConverter_ConvertValueUnit_throws_UnitsNetException_
             Assert.Equal("UnitsNet.Units.SomeImaginaryUnit,UnitsNet", result.Data["type"]);
         }
 
-        [Fact]
-        public void UnitsNetBaseJsonConverter_ConvertValueUnit_throws_UnitsNetException_when_unit_is_in_unexpected_format()
-        {
-            var result = Assert.Throws<UnitsNetException>(() => _sut.Test_ConvertDecimalValueUnit("PowerUnit Watt", 10.2365m));
-
-            Assert.Equal("\"PowerUnit Watt\" is not a valid unit.", result.Message);
-            Assert.True(result.Data.Contains("type"));
-            Assert.Equal("PowerUnit Watt", result.Data["type"]);
-        }
-
         [Fact]
         public void UnitsNetBaseJsonConverter_CreateLocalSerializer_works_as_expected()
         {
@@ -107,38 +86,6 @@ public void UnitsNetBaseJsonConverter_ReadValueUnit_works_with_double_quantity()
             Assert.Equal(10.2365, result?.Value);
         }
 
-        [Fact]
-        public void UnitsNetBaseJsonConverter_ReadValueUnit_works_with_decimal_quantity()
-        {
-            var token = new JObject {{"Unit", "PowerUnit.Watt"}, {"Value", 10.2365m}, {"ValueString", "10.2365"}, {"ValueType", "decimal"}};
-
-            var result = _sut.Test_ReadDecimalValueUnit(token);
-
-            Assert.NotNull(result);
-            Assert.Equal("PowerUnit.Watt", result?.Unit);
-            Assert.Equal(10.2365m, result?.Value);
-        }
-
-        [Fact]
-        public void UnitsNetBaseJsonConverter_ReadValueUnit_returns_null_when_value_is_a_string()
-        {
-            var token = new JObject {{"Unit", "PowerUnit.Watt"}, {"Value", "10.2365"}};
-
-            var result = _sut.Test_ReadDecimalValueUnit(token);
-
-            Assert.Null(result);
-        }
-
-        [Fact]
-        public void UnitsNetBaseJsonConverter_ReadValueUnit_returns_null_when_value_type_is_not_a_string()
-        {
-            var token = new JObject {{"Unit", "PowerUnit.Watt"}, {"Value", 10.2365}, {"ValueType", 123}};
-
-            var result = _sut.Test_ReadDecimalValueUnit(token);
-
-            Assert.Null(result);
-        }
-
         [Fact]
         public void UnitsNetBaseJsonConverter_ReadDoubleValueUnit_works_with_empty_token()
         {
@@ -149,55 +96,6 @@ public void UnitsNetBaseJsonConverter_ReadDoubleValueUnit_works_with_empty_token
             Assert.Null(result);
         }
 
-        [Theory]
-        [InlineData(false, true)]
-        [InlineData(true, false)]
-        public void UnitsNetBaseJsonConverter_ReadValueUnit_returns_null_when_unit_or_value_is_missing(bool withUnit, bool withValue)
-        {
-            var token = new JObject();
-
-            if (withUnit)
-            {
-                token.Add("Unit", "PowerUnit.Watt");
-            }
-
-            if (withValue)
-            {
-                token.Add("Value", 10.2365m);
-            }
-
-            var result = _sut.Test_ReadDecimalValueUnit(token);
-
-            Assert.Null(result);
-        }
-
-        [Theory]
-        [InlineData("Unit", "Value", "ValueString", "ValueType")]
-        [InlineData("unit", "Value", "ValueString", "ValueType")]
-        [InlineData("Unit", "value", "valueString", "valueType")]
-        [InlineData("unit", "value", "valueString", "valueType")]
-        [InlineData("unIT", "vAlUe", "vAlUeString", "vAlUeType")]
-        public void UnitsNetBaseJsonConverter_ReadValueUnit_works_case_insensitive(
-            string unitPropertyName,
-            string valuePropertyName,
-            string valueStringPropertyName,
-            string valueTypePropertyName)
-        {
-            var token = new JObject
-            {
-                {unitPropertyName, "PowerUnit.Watt"},
-                {valuePropertyName, 10.2365m},
-                {valueStringPropertyName, 10.2365m.ToString(CultureInfo.InvariantCulture)},
-                {valueTypePropertyName, "decimal"}
-            };
-
-            var result = _sut.Test_ReadDecimalValueUnit(token);
-
-            Assert.NotNull(result);
-            Assert.Equal("PowerUnit.Watt", result?.Unit);
-            Assert.Equal(10.2365m, result?.Value);
-        }
-
         /// <summary>
         /// Dummy converter, used to access protected methods on abstract UnitsNetBaseJsonConverter{T}
         /// </summary>
@@ -214,24 +112,8 @@ private class TestConverter : UnitsNetBaseJsonConverter<string>
                 return (result.Unit, result.Value);
             }
 
-            public (string Unit, decimal Value) Test_ConvertDecimalIQuantity(IQuantity value)
-            {
-                var result = ConvertIQuantity(value);
-                if (result is ExtendedValueUnit {ValueType: "decimal"} decimalResult)
-                {
-                    return (result.Unit, decimal.Parse(decimalResult.ValueString, CultureInfo.InvariantCulture));
-                }
-
-                throw new ArgumentException("The quantity does not have a decimal value", nameof(value));
-            }
-
             public IQuantity Test_ConvertDoubleValueUnit(string unit, double value) => Test_ConvertValueUnit(new ValueUnit {Unit = unit, Value = value});
 
-            public IQuantity Test_ConvertDecimalValueUnit(string unit, decimal value) => Test_ConvertValueUnit(new ExtendedValueUnit
-            {
-                Unit = unit, Value = (double) value, ValueString = value.ToString(CultureInfo.InvariantCulture), ValueType = "decimal"
-            });
-
             private IQuantity Test_ConvertValueUnit(ValueUnit valueUnit) => ConvertValueUnit(valueUnit);
 
             public JsonSerializer Test_CreateLocalSerializer(JsonSerializer serializer) => CreateLocalSerializer(serializer, this);
@@ -246,19 +128,6 @@ public IQuantity Test_ConvertDecimalValueUnit(string unit, decimal value) => Tes
 
                 return (result.Unit, result.Value);
             }
-
-            public (string Unit, decimal Value)? Test_ReadDecimalValueUnit(JToken jsonToken)
-            {
-                var result = ReadValueUnit(jsonToken);
-
-                if (result is ExtendedValueUnit {ValueType: "decimal"} decimalResult)
-                {
-                    return (result.Unit, decimal.Parse(decimalResult.ValueString, CultureInfo.InvariantCulture));
-                }
-
-                return null;
-            }
-
         }
     }
 }
diff --git a/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs b/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
index 9dae845683..6e9d2940bd 100644
--- a/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
+++ b/UnitsNet.Serialization.JsonNet/UnitsNetBaseJsonConverter.cs
@@ -57,38 +57,20 @@ public void RegisterCustomType(Type quantity, Type unit)
 
             var unit = jsonObject.GetValue(nameof(ValueUnit.Unit), StringComparison.OrdinalIgnoreCase);
             var value = jsonObject.GetValue(nameof(ValueUnit.Value), StringComparison.OrdinalIgnoreCase);
-            var valueType = jsonObject.GetValue(nameof(ExtendedValueUnit.ValueType), StringComparison.OrdinalIgnoreCase);
-            var valueString = jsonObject.GetValue(nameof(ExtendedValueUnit.ValueString), StringComparison.OrdinalIgnoreCase);
 
             if (unit == null || value == null)
             {
                 return null;
             }
 
-            if (valueType == null)
-            {
-                if (value.Type != JTokenType.Float && value.Type != JTokenType.Integer)
-                {
-                    return null;
-                }
-
-                return new ValueUnit {
-                    Unit = unit.Value<string>() ?? throw new InvalidOperationException("Unit was not a string."),
-                    Value = value.Value<double>()
-                };
-            }
-
-            if (valueType.Type != JTokenType.String)
+            if (value.Type != JTokenType.Float && value.Type != JTokenType.Integer)
             {
                 return null;
             }
 
-            return new ExtendedValueUnit
-            {
+            return new ValueUnit {
                 Unit = unit.Value<string>() ?? throw new InvalidOperationException("Unit was not a string."),
-                Value = value.Value<double>(),
-                ValueType = valueType.Value<string>(),
-                ValueString = valueString?.Value<string>()
+                Value = value.Value<double>()
             };
         }
 
@@ -247,27 +229,5 @@ protected class ValueUnit
             [JsonProperty(Order = 2)]
             public double Value { get; set; }
         }
-
-        /// <summary>
-        ///     A structure used to serialize/deserialize non-double Units.NET unit instances.
-        /// </summary>
-        /// <remarks>
-        ///     This type was added for lossless serialization of quantities with <see cref="decimal"/> values.
-        ///     The <see cref="decimal"/> type distinguishes between 100 and 100.00 but Json.NET does not, therefore we serialize decimal values as string.
-        /// </remarks>
-        protected sealed class ExtendedValueUnit : ValueUnit
-        {
-            /// <summary>
-            ///     The value as a string.
-            /// </summary>
-            [JsonProperty(Order = 3)]
-            public string? ValueString { get; set; }
-
-            /// <summary>
-            ///     The type of the value, e.g. "decimal".
-            /// </summary>
-            [JsonProperty(Order = 4)]
-            public string? ValueType { get; set; }
-        }
     }
 }

From ef1569a19ac084b811994f54c0d8e3250009c008 Mon Sep 17 00:00:00 2001
From: Muximize <Muximize@users.noreply.github.com>
Date: Thu, 25 Jan 2024 02:02:14 +0100
Subject: [PATCH 05/11] Remove last bits of decimal support

---
 UnitsNet.Tests/AssertEx.cs                    |  18 ---
 UnitsNet/Comparison.cs                        | 112 ------------------
 .../DecimalGenericMathExtensions.cs           |  50 --------
 UnitsNet/GenericMath/GenericMathExtensions.cs |   4 -
 UnitsNet/QuantityFormatter.cs                 |   6 +-
 5 files changed, 2 insertions(+), 188 deletions(-)
 delete mode 100644 UnitsNet/GenericMath/DecimalGenericMathExtensions.cs

diff --git a/UnitsNet.Tests/AssertEx.cs b/UnitsNet.Tests/AssertEx.cs
index 229e4324e7..d052adfeec 100644
--- a/UnitsNet.Tests/AssertEx.cs
+++ b/UnitsNet.Tests/AssertEx.cs
@@ -25,23 +25,5 @@ public static void EqualTolerance(double expected, double actual, double toleran
                 Assert.True( areEqual, $"Values are not equal within absolute tolerance: {tolerance}\nExpected: {expected}\nActual: {actual}\nDiff: {actual - expected:e}" );
             }
         }
-
-        public static void EqualTolerance(decimal expected, decimal actual, decimal tolerance, ComparisonType comparisonType = ComparisonType.Relative)
-        {
-            if (comparisonType == ComparisonType.Relative)
-            {
-                bool areEqual = Comparison.EqualsRelative(expected, actual, tolerance);
-
-                decimal difference = Math.Abs(expected - actual);
-                decimal relativeDifference = difference / expected;
-
-                Assert.True(areEqual, $"Values are not equal within relative tolerance: {tolerance:P4}\nExpected: {expected}\nActual: {actual}\nDiff: {relativeDifference:P4}");
-            }
-            else if (comparisonType == ComparisonType.Absolute)
-            {
-                bool areEqual = Comparison.EqualsAbsolute(expected, actual, tolerance);
-                Assert.True(areEqual, $"Values are not equal within absolute tolerance: {tolerance}\nExpected: {expected}\nActual: {actual}\nDiff: {actual - expected:e}");
-            }
-        }
     }
 }
diff --git a/UnitsNet/Comparison.cs b/UnitsNet/Comparison.cs
index 6c5a405a9d..8971906b04 100644
--- a/UnitsNet/Comparison.cs
+++ b/UnitsNet/Comparison.cs
@@ -65,61 +65,6 @@ public static bool Equals(double referenceValue, double otherValue, double toler
             }
         }
 
-        /// <summary>
-        ///     <para>
-        ///         Checks if two values are equal with a given relative or absolute tolerance.
-        ///     </para>
-        ///     <para>
-        ///         Relative tolerance is defined as the maximum allowable absolute difference between
-        ///         <paramref name="referenceValue" /> and
-        ///         <paramref name="otherValue" /> as a percentage of <paramref name="referenceValue" />. A relative tolerance of
-        ///         0.01 means the
-        ///         absolute difference of <paramref name="referenceValue" /> and <paramref name="otherValue" /> must be within +/-
-        ///         1%.
-        ///         <example>
-        ///             In this example, the two values will be equal if the value of b is within +/- 1% of a.
-        ///             <code>
-        ///     Equals(a, b, 0.01, ComparisonType.Relative);
-        ///     </code>
-        ///         </example>
-        ///     </para>
-        ///     <para>
-        ///         Absolute tolerance is defined as the maximum allowable absolute difference between
-        ///         <paramref name="referenceValue" /> and
-        ///         <paramref name="otherValue" /> as a fixed number.
-        ///         <example>
-        ///             In this example, the two values will be equal if abs(<paramref name="referenceValue" /> -
-        ///             <paramref name="otherValue" />) &lt;= 0.01
-        ///             <code>
-        ///     Equals(a, b, 0.01, ComparisonType.Absolute);
-        ///     </code>
-        ///         </example>
-        ///     </para>
-        /// </summary>
-        /// <param name="referenceValue">
-        ///     The reference value. If using relative tolerance, it is the value which the relative
-        ///     tolerance will be calculated against.
-        /// </param>
-        /// <param name="otherValue">The value to compare to.</param>
-        /// <param name="tolerance">The absolute or relative tolerance value. Must be greater than or equal to 0.</param>
-        /// <param name="comparisonType">Whether the tolerance is absolute or relative.</param>
-        /// <returns></returns>
-        public static bool Equals(decimal referenceValue, decimal otherValue, decimal tolerance, ComparisonType comparisonType)
-        {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
-
-            switch (comparisonType)
-            {
-                case ComparisonType.Relative:
-                    return EqualsRelative(referenceValue, otherValue, tolerance);
-                case ComparisonType.Absolute:
-                    return EqualsAbsolute(referenceValue, otherValue, tolerance);
-                default:
-                    throw new InvalidOperationException("The given ComparisonType is not supported.");
-            }
-        }
-
         /// <summary>
         ///     Checks if two values are equal with a given relative tolerance.
         ///     <para>
@@ -150,36 +95,6 @@ public static bool EqualsRelative(double referenceValue, double otherValue, doub
             return Math.Abs(referenceValue - otherValue) <= maxVariation;
         }
 
-        /// <summary>
-        ///     Checks if two values are equal with a given relative tolerance.
-        ///     <para>
-        ///         Relative tolerance is defined as the maximum allowable absolute difference between
-        ///         <paramref name="referenceValue" /> and
-        ///         <paramref name="otherValue" /> as a percentage of <paramref name="referenceValue" />. A relative tolerance of
-        ///         0.01 means the
-        ///         absolute difference of <paramref name="referenceValue" /> and <paramref name="otherValue" /> must be within +/-
-        ///         1%.
-        ///         <example>
-        ///             In this example, the two values will be equal if the value of b is within +/- 1% of a.
-        ///             <code>
-        ///     EqualsRelative(a, b, 0.01);
-        ///     </code>
-        ///         </example>
-        ///     </para>
-        /// </summary>
-        /// <param name="referenceValue">The reference value which the tolerance will be calculated against.</param>
-        /// <param name="otherValue">The value to compare to.</param>
-        /// <param name="tolerance">The relative tolerance. Must be greater than or equal to 0.</param>
-        /// <returns>True if the two values are equal within the given relative tolerance, otherwise false.</returns>
-        public static bool EqualsRelative(decimal referenceValue, decimal otherValue, decimal tolerance)
-        {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
-
-            var maxVariation = Math.Abs(referenceValue * tolerance);
-            return Math.Abs(referenceValue - otherValue) <= maxVariation;
-        }
-
         /// <summary>
         ///     Checks if two values are equal with a given absolute tolerance.
         ///     <para>
@@ -206,32 +121,5 @@ public static bool EqualsAbsolute(double value1, double value2, double tolerance
 
             return Math.Abs(value1 - value2) <= tolerance;
         }
-
-        /// <summary>
-        ///     Checks if two values are equal with a given absolute tolerance.
-        ///     <para>
-        ///         Absolute tolerance is defined as the maximum allowable absolute difference between <paramref name="value1" />
-        ///         and
-        ///         <paramref name="value2" /> as a fixed number.
-        ///         <example>
-        ///             In this example, the two values will be equal if abs(<paramref name="value1" /> -
-        ///             <paramref name="value2" />) &lt;= 0.01
-        ///             <code>
-        ///     Equals(a, b, 0.01, ComparisonType.Absolute);
-        ///     </code>
-        ///         </example>
-        ///     </para>
-        /// </summary>
-        /// <param name="value1">The first value.</param>
-        /// <param name="value2">The second value.</param>
-        /// <param name="tolerance">The absolute tolerance. Must be greater than or equal to 0.</param>
-        /// <returns>True if the two values are equal within the given absolute tolerance, otherwise false.</returns>
-        public static bool EqualsAbsolute(decimal value1, decimal value2, decimal tolerance)
-        {
-            if (tolerance < 0)
-                throw new ArgumentOutOfRangeException(nameof(tolerance), "Tolerance must be greater than or equal to 0");
-
-            return Math.Abs(value1 - value2) <= tolerance;
-        }
     }
 }
diff --git a/UnitsNet/GenericMath/DecimalGenericMathExtensions.cs b/UnitsNet/GenericMath/DecimalGenericMathExtensions.cs
deleted file mode 100644
index 2c686c9d90..0000000000
--- a/UnitsNet/GenericMath/DecimalGenericMathExtensions.cs
+++ /dev/null
@@ -1,50 +0,0 @@
-// 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.
-
-#if NET7_0_OR_GREATER
-
-using System.Collections.Generic;
-using System.Linq;
-using System.Numerics;
-
-namespace UnitsNet.GenericMath;
-
-/// <summary>
-///     Provides generic math operations to test out the new generic math interfaces implemented in .NET7 for UnitsNet
-///     quantities using <see cref="decimal" /> as the internal value type, such as <see cref="Power" />, <see cref="BitRate" /> and
-///     <see cref="Information" />.
-/// </summary>
-/// <remarks>
-///     See <see cref="GenericMathExtensions" /> for quantities using <see cref="double" /> as the internal value type.
-/// </remarks>
-public static class DecimalGenericMathExtensions
-{
-    /// <summary>
-    ///     Returns the average of values.
-    /// </summary>
-    /// <remarks>
-    ///     This method is experimental and intended to test out the new generic math interfaces implemented in .NET7 for
-    ///     UnitsNet quantities.<br />
-    ///     Generic math interfaces might replace <see cref="UnitMath" />.<br />
-    ///     Generic math LINQ support is still missing in the BCL, but is being worked on:
-    ///     <a href="https://github.com/dotnet/runtime/issues/64031">
-    ///         API Proposal: Generic LINQ Numeric Operators · Issue
-    ///         #64031 · dotnet/runtime
-    ///     </a>
-    /// </remarks>
-    /// <param name="source">The values.</param>
-    /// <typeparam name="T">The value type.</typeparam>
-    /// <returns>The average.</returns>
-    public static T Average<T>(this IEnumerable<T> source)
-        where T : IAdditionOperators<T, T, T>, IAdditiveIdentity<T, T>, IDivisionOperators<T, decimal, T>
-    {
-        // Put accumulator on right hand side of the addition operator to construct quantities with the same unit as the values.
-        // The addition operator implementation picks the unit from the left hand side, and the additive identity (e.g. Length.Zero) is always the base unit.
-        (T value, int count) result = source.Aggregate(
-            (value: T.AdditiveIdentity, count: 0),
-            (acc, item) => (value: item + acc.value, count: acc.count + 1));
-
-        return result.value / result.count;
-    }
-}
-#endif
diff --git a/UnitsNet/GenericMath/GenericMathExtensions.cs b/UnitsNet/GenericMath/GenericMathExtensions.cs
index c9b46844ce..9ef41a69e4 100644
--- a/UnitsNet/GenericMath/GenericMathExtensions.cs
+++ b/UnitsNet/GenericMath/GenericMathExtensions.cs
@@ -12,10 +12,6 @@ namespace UnitsNet.GenericMath;
 ///     Provides generic math operations to test out the new generic math interfaces implemented in .NET7 for UnitsNet
 ///     quantities using <see cref="double" /> as the internal value type, which is the majority of quantities.
 /// </summary>
-/// <remarks>
-///     See <see cref="DecimalGenericMathExtensions" /> for quantities using <see cref="decimal" /> as the internal value
-///     type.
-/// </remarks>
 public static class GenericMathExtensions
 {
     /// <summary>
diff --git a/UnitsNet/QuantityFormatter.cs b/UnitsNet/QuantityFormatter.cs
index 4d8a10d1ce..fcbca7350d 100644
--- a/UnitsNet/QuantityFormatter.cs
+++ b/UnitsNet/QuantityFormatter.cs
@@ -180,10 +180,8 @@ private static string FormatUntrimmed<TUnitType>(IQuantity<TUnitType> quantity,
 
         private static string ToStringWithSignificantDigitsAfterRadix<TUnitType>(IQuantity<TUnitType> quantity, IFormatProvider formatProvider, int number) where TUnitType : Enum
         {
-            // When a fixed number of digits after the dot is expected, double and decimal behave the same.
-            var value = (double)quantity.Value;
-            string formatForSignificantDigits = UnitFormatter.GetFormat(value, number);
-            object[] formatArgs = UnitFormatter.GetFormatArgs(quantity.Unit, value, formatProvider, Enumerable.Empty<object>());
+            string formatForSignificantDigits = UnitFormatter.GetFormat(quantity.Value, number);
+            object[] formatArgs = UnitFormatter.GetFormatArgs(quantity.Unit, quantity.Value, formatProvider, Enumerable.Empty<object>());
             return string.Format(formatProvider, formatForSignificantDigits, formatArgs);
         }
     }

From 137d6014d6c4b66285f41311889d7100ee91e750 Mon Sep 17 00:00:00 2001
From: Muximize <Muximize@users.noreply.github.com>
Date: Sat, 27 Jan 2024 00:57:55 +0100
Subject: [PATCH 06/11] Remove decimal support from CodeGen

---
 .../NanoFrameworkGen/QuantityGenerator.cs     | 37 +++------
 CodeGen/Generators/NanoFrameworkGenerator.cs  | 14 ----
 CodeGen/Generators/QuantityJsonFilesParser.cs | 15 ----
 .../UnitsNetGen/QuantityGenerator.cs          | 77 ++++++-------------
 .../UnitsNetGen/UnitTestBaseClassGenerator.cs | 38 ++++-----
 CodeGen/JsonTypes/Quantity.cs                 |  1 -
 CodeGen/PrefixInfo.cs                         |  3 -
 7 files changed, 48 insertions(+), 137 deletions(-)

diff --git a/CodeGen/Generators/NanoFrameworkGen/QuantityGenerator.cs b/CodeGen/Generators/NanoFrameworkGen/QuantityGenerator.cs
index 721c9a94ce..10aca1bc75 100644
--- a/CodeGen/Generators/NanoFrameworkGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/NanoFrameworkGen/QuantityGenerator.cs
@@ -43,7 +43,7 @@ public struct  {_quantity.Name}
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        private readonly {_quantity.ValueType} _value;
+        private readonly double _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -53,7 +53,7 @@ public struct  {_quantity.Name}
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public {_quantity.ValueType} Value => _value;
+        public double Value => _value;
 
         /// <inheritdoc />
         public {_unitEnumName} Unit => _unit;
@@ -66,7 +66,7 @@ public struct  {_quantity.Name}
         /// <param name=""value"">The numeric value to construct this quantity with.</param>
         /// <param name=""unit"">The unit representation to construct this quantity with.</param>
         /// <exception cref=""ArgumentException"">If value is NaN or Infinity.</exception>
-        public {_quantity.Name}({_quantity.ValueType} value, {_unitEnumName} unit)
+        public {_quantity.Name}(double value, {_unitEnumName} unit)
         {{
             _value = value;
             _unit = unit;
@@ -79,29 +79,14 @@ public struct  {_quantity.Name}
 
         /// <summary>
         /// Represents the largest possible value of {_quantity.Name}.
-        /// </summary>");
-
-            // Non decimal
-            Writer.WLCondition(_quantity.ValueType != "decimal", $@"
-        public static {_quantity.Name} MaxValue {{ get; }} = new {_quantity.Name}({_quantity.ValueType}.MaxValue, BaseUnit);
-
-        /// <summary>
-        /// Represents the smallest possible value of {_quantity.Name}.
         /// </summary>
-        public static {_quantity.Name} MinValue {{ get; }} = new {_quantity.Name}({_quantity.ValueType}.MinValue, BaseUnit);
-");
-
-            // Decimal MaxValue = 79228162514264337593543950335M
-            Writer.WLCondition(_quantity.ValueType == "decimal", $@"
-        public static {_quantity.Name} MaxValue {{ get; }} = new {_quantity.Name}(79228162514264337593543950335M, BaseUnit);
+        public static {_quantity.Name} MaxValue {{ get; }} = new {_quantity.Name}(double.MaxValue, BaseUnit);
 
         /// <summary>
         /// Represents the smallest possible value of {_quantity.Name}.
         /// </summary>
-        public static {_quantity.Name} MinValue {{ get; }} = new {_quantity.Name}(-79228162514264337593543950335M, BaseUnit);
-");
+        public static {_quantity.Name} MinValue {{ get; }} = new {_quantity.Name}(double.MinValue, BaseUnit);
 
-            Writer.WL($@"
         /// <summary>
         ///     Gets an instance of this quantity with a value of 0 in the base unit Second.
         /// </summary>
@@ -134,7 +119,7 @@ private void GenerateConversionProperties()
         /// </summary>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public {_quantity.ValueType} {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
+        public double {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
 ");
             }
 
@@ -161,7 +146,7 @@ private void GenerateStaticFactoryMethods()
         /// <exception cref=""ArgumentException"">If value is NaN or Infinity.</exception>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public static {_quantity.Name} From{unit.PluralName}({_quantity.ValueType} {valueParamName}) => new {_quantity.Name}({valueParamName}, {_unitEnumName}.{unit.SingularName});
+        public static {_quantity.Name} From{unit.PluralName}(double {valueParamName}) => new {_quantity.Name}({valueParamName}, {_unitEnumName}.{unit.SingularName});
 ");
             }
 
@@ -172,7 +157,7 @@ private void GenerateStaticFactoryMethods()
         /// <param name=""value"">Value to convert from.</param>
         /// <param name=""fromUnit"">Unit to convert from.</param>
         /// <returns>{_quantity.Name} unit value.</returns>
-        public static {_quantity.Name} From({_quantity.ValueType} value, {_unitEnumName} fromUnit)
+        public static {_quantity.Name} From(double value, {_unitEnumName} fromUnit)
         {{
             return new {_quantity.Name}(value, fromUnit);
         }}
@@ -190,7 +175,7 @@ private void GenerateConversionMethods()
                 ///     Convert to the unit representation <paramref name=""unit"" />.
                 /// </summary>
                 /// <returns>Value converted to the specified unit.</returns>
-                public {_quantity.ValueType} As({_unitEnumName} unit) => GetValueAs(unit);
+                public double As({_unitEnumName} unit) => GetValueAs(unit);
 
                 /// <summary>
                 ///     Converts this {_quantity.Name} to another {_quantity.Name} with the unit representation <paramref name=""unit"" />.
@@ -207,7 +192,7 @@ private void GenerateConversionMethods()
                 ///     This is typically the first step in converting from one unit to another.
                 /// </summary>
                 /// <returns>The value in the base unit representation.</returns>
-                private {_quantity.ValueType} GetValueInBaseUnit()
+                private double GetValueInBaseUnit()
                 {{
                     return Unit switch
                     {{");
@@ -223,7 +208,7 @@ private void GenerateConversionMethods()
                     }};
                     }}
 
-                private {_quantity.ValueType} GetValueAs({_unitEnumName} unit)
+                private double GetValueAs({_unitEnumName} unit)
                 {{
                     if (Unit == unit)
                         return _value;
diff --git a/CodeGen/Generators/NanoFrameworkGenerator.cs b/CodeGen/Generators/NanoFrameworkGenerator.cs
index 1753235749..19d8cab43c 100644
--- a/CodeGen/Generators/NanoFrameworkGenerator.cs
+++ b/CodeGen/Generators/NanoFrameworkGenerator.cs
@@ -90,20 +90,6 @@ public static void Generate(string rootDir, Quantity[] quantities, QuantityNameT
                 GenerateQuantity(quantity, Path.Combine(outputQuantities, $"{quantity.Name}.g.cs"));
                 GenerateProject(quantity, Path.Combine(projectPath, $"{quantity.Name}.nfproj"), versions);
 
-                // Convert decimal based units to floats; decimals are not supported by nanoFramework
-                if (quantity.ValueType == "decimal")
-                {
-                    var replacements = new Dictionary<string, string>
-                    {
-                        { "(\\d)m", "$1d" },
-                        { "(\\d)M", "$1d" },
-                        { " decimal ", " double " },
-                        { "(decimal ", "(double " }
-                    };
-                    new FileInfo(Path.Combine(outputDir, "Units", $"{quantity.Name}Unit.g.cs")).EditFile(replacements);
-                    new FileInfo(Path.Combine(outputDir, "Quantities", $"{quantity.Name}.g.cs")).EditFile(replacements);
-                }
-
                 Log.Information("✅ {Quantity} (nanoFramework)", quantity.Name);
             }
             Log.Information("");
diff --git a/CodeGen/Generators/QuantityJsonFilesParser.cs b/CodeGen/Generators/QuantityJsonFilesParser.cs
index 316e785fd6..a9393e9efa 100644
--- a/CodeGen/Generators/QuantityJsonFilesParser.cs
+++ b/CodeGen/Generators/QuantityJsonFilesParser.cs
@@ -48,7 +48,6 @@ private static Quantity ParseQuantityFile(string jsonFileName)
                                ?? throw new UnitsNetCodeGenException($"Unable to parse quantity from JSON file: {jsonFileName}");
 
                 AddPrefixUnits(quantity);
-                FixConversionFunctionsForDecimalValueTypes(quantity);
                 OrderUnitsByName(quantity);
                 return quantity;
             }
@@ -63,20 +62,6 @@ private static void OrderUnitsByName(Quantity quantity)
             quantity.Units = quantity.Units.OrderBy(u => u.SingularName, StringComparer.OrdinalIgnoreCase).ToArray();
         }
 
-        private static void FixConversionFunctionsForDecimalValueTypes(Quantity quantity)
-        {
-            foreach (Unit u in quantity.Units)
-                // Use decimal for internal calculations if base type is not double, such as for long or int.
-            {
-                if (string.Equals(quantity.ValueType, "decimal", StringComparison.OrdinalIgnoreCase))
-                {
-                    // Change any double literals like "1024d" to decimal literals "1024m"
-                    u.FromUnitToBaseFunc = u.FromUnitToBaseFunc.Replace("d", "m");
-                    u.FromBaseToUnitFunc = u.FromBaseToUnitFunc.Replace("d", "m");
-                }
-            }
-        }
-
         private static void AddPrefixUnits(Quantity quantity)
         {
             var unitsToAdd = new List<Unit>();
diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index 8f9fa6fa1d..72a9b5cfdc 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
@@ -14,7 +14,6 @@ internal class QuantityGenerator : GeneratorBase
 
         private readonly bool _isDimensionless;
         private readonly string _unitEnumName;
-        private readonly string _valueType;
         private readonly Unit _baseUnit;
 
         public QuantityGenerator(Quantity quantity)
@@ -25,7 +24,6 @@ public QuantityGenerator(Quantity quantity)
                         throw new ArgumentException($"No unit found with SingularName equal to BaseUnit [{_quantity.BaseUnit}]. This unit must be defined.",
                             nameof(quantity));
 
-            _valueType = quantity.ValueType;
             _unitEnumName = $"{quantity.Name}Unit";
 
             BaseDimensions baseDimensions = quantity.BaseDimensions;
@@ -100,9 +98,6 @@ namespace UnitsNet
 #endif");
             }
 
-            if (_quantity.ValueType == "decimal") Writer.WL(@$"
-        IDecimalQuantity,");
-
             Writer.WL(@$"
         IComparable,
         IComparable<{_quantity.Name}>,
@@ -116,7 +111,7 @@ namespace UnitsNet
         ///     The numeric value this quantity was constructed with.
         /// </summary>
         [DataMember(Name = ""Value"", Order = 1)]
-        private readonly {_quantity.ValueType} _value;
+        private readonly double _value;
 
         /// <summary>
         ///     The unit this quantity was constructed with.
@@ -209,7 +204,7 @@ private void GenerateInstanceConstructors()
         /// <param name=""value"">The numeric value to construct this quantity with.</param>
         /// <param name=""unit"">The unit representation to construct this quantity with.</param>
         /// <exception cref=""ArgumentException"">If value is NaN or Infinity.</exception>
-        public {_quantity.Name}({_quantity.ValueType} value, {_unitEnumName} unit)
+        public {_quantity.Name}(double value, {_unitEnumName} unit)
         {{");
             Writer.WL(@"
             _value = value;");
@@ -225,7 +220,7 @@ private void GenerateInstanceConstructors()
         /// <param name=""unitSystem"">The unit system to create the quantity with.</param>
         /// <exception cref=""ArgumentNullException"">The given <see cref=""UnitSystem""/> is null.</exception>
         /// <exception cref=""ArgumentException"">No unit was found for the given <see cref=""UnitSystem""/>.</exception>
-        public {_quantity.Name}({_valueType} value, UnitSystem unitSystem)
+        public {_quantity.Name}(double value, UnitSystem unitSystem)
         {{
             if (unitSystem is null) throw new ArgumentNullException(nameof(unitSystem));
 
@@ -296,7 +291,7 @@ private void GenerateProperties()
         /// <summary>
         ///     The numeric value this quantity was constructed with.
         /// </summary>
-        public {_valueType} Value => _value;
+        public double Value => _value;
 
         /// <inheritdoc />
         double IQuantity.Value => _value;
@@ -332,11 +327,11 @@ private void GenerateConversionProperties()
 
                 Writer.WL($@"
         /// <summary>
-        ///     Gets a <see cref=""{_quantity.ValueType}""/> value of this quantity converted into <see cref=""{_unitEnumName}.{unit.SingularName}""/>
+        ///     Gets a <see cref=""double""/> value of this quantity converted into <see cref=""{_unitEnumName}.{unit.SingularName}""/>
         /// </summary>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public {_quantity.ValueType} {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
+        public double {unit.PluralName} => As({_unitEnumName}.{unit.SingularName});
 ");
             }
 
@@ -431,8 +426,7 @@ private void GenerateStaticFactoryMethods()
                 Writer.WL($@"
         public static {_quantity.Name} From{unit.PluralName}(double {valueParamName})
         {{
-            {_valueType} value = ({_valueType}) {valueParamName};
-            return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName});
+            return new {_quantity.Name}({valueParamName}, {_unitEnumName}.{unit.SingularName});
         }}
 ");
             }
@@ -446,7 +440,7 @@ private void GenerateStaticFactoryMethods()
         /// <returns>{_quantity.Name} unit value.</returns>
         public static {_quantity.Name} From(double value, {_unitEnumName} fromUnit)
         {{
-            return new {_quantity.Name}(({_valueType})value, fromUnit);
+            return new {_quantity.Name}(value, fromUnit);
         }}
 
         #endregion
@@ -635,25 +629,25 @@ private void GenerateArithmeticOperators()
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from multiplying value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_valueType} left, {_quantity.Name} right)
+        public static {_quantity.Name} operator *(double left, {_quantity.Name} right)
         {{
             return new {_quantity.Name}(left * right.Value, right.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from multiplying value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_quantity.Name} left, {_valueType} right)
+        public static {_quantity.Name} operator *({_quantity.Name} left, double right)
         {{
             return new {_quantity.Name}(left.Value * right, left.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from dividing <see cref=""{_quantity.Name}""/> by value.</summary>
-        public static {_quantity.Name} operator /({_quantity.Name} left, {_valueType} right)
+        public static {_quantity.Name} operator /({_quantity.Name} left, double right)
         {{
             return new {_quantity.Name}(left.Value / right, left.Unit);
         }}
 
         /// <summary>Get ratio value from dividing <see cref=""{_quantity.Name}""/> by <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.ValueType} operator /({_quantity.Name} left, {_quantity.Name} right)
+        public static double operator /({_quantity.Name} left, {_quantity.Name} right)
         {{
             return left.{_baseUnit.PluralName} / right.{_baseUnit.PluralName};
         }}
@@ -693,7 +687,7 @@ private void GenerateLogarithmicArithmeticOperators()
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic multiplication of value and <see cref=""{_quantity.Name}""/>.</summary>
-        public static {_quantity.Name} operator *({_valueType} left, {_quantity.Name} right)
+        public static {_quantity.Name} operator *(double left, {_quantity.Name} right)
         {{
             // Logarithmic multiplication = addition
             return new {_quantity.Name}(left + right.Value, right.Unit);
@@ -703,14 +697,14 @@ private void GenerateLogarithmicArithmeticOperators()
         public static {_quantity.Name} operator *({_quantity.Name} left, double right)
         {{
             // Logarithmic multiplication = addition
-            return new {_quantity.Name}(left.Value + ({_valueType})right, left.Unit);
+            return new {_quantity.Name}(left.Value + right, left.Unit);
         }}
 
         /// <summary>Get <see cref=""{_quantity.Name}""/> from logarithmic division of <see cref=""{_quantity.Name}""/> by value.</summary>
         public static {_quantity.Name} operator /({_quantity.Name} left, double right)
         {{
             // Logarithmic division = subtraction
-            return new {_quantity.Name}(left.Value - ({_valueType})right, left.Unit);
+            return new {_quantity.Name}(left.Value - right, left.Unit);
         }}
 
         /// <summary>Get ratio value from logarithmic division of <see cref=""{_quantity.Name}""/> by <see cref=""{_quantity.Name}""/>.</summary>
@@ -783,13 +777,10 @@ private void GenerateRelationalOperators()
                     {
                         rightParameter = rightPart = "value";
                     }
+                    
+                    var expression = $"{leftPart} {relation.Operator} {rightPart}";
 
-                    var leftCast = relation.LeftQuantity.ValueType is "decimal" ? "(double)" : string.Empty;
-                    var rightCast = relation.RightQuantity.ValueType is "decimal" ? "(double)" : string.Empty;
-
-                    var expression = $"{leftCast}{leftPart} {relation.Operator} {rightCast}{rightPart}";
-
-                    if (relation.ResultQuantity.Name is not ("double" or "decimal"))
+                    if (relation.ResultQuantity.Name is not "double")
                     {
                         expression = $"{relation.ResultQuantity.Name}.From{relation.ResultUnit.PluralName}({expression})";
                     }
@@ -947,7 +938,7 @@ public int CompareTo({_quantity.Name} other)
         ///     </para>
         ///     <para>
         ///     Note that it is advised against specifying zero difference, due to the nature
-        ///     of floating-point operations and using {_valueType} internally.
+        ///     of floating-point operations and using double internally.
         ///     </para>
         /// </summary>
         /// <param name=""other"">The other quantity to compare to.</param>
@@ -955,7 +946,7 @@ public int CompareTo({_quantity.Name} other)
         /// <param name=""comparisonType"">The comparison type: either relative or absolute.</param>
         /// <returns>True if the absolute difference between the two values is not greater than the specified relative or absolute tolerance.</returns>
         [Obsolete(""Use Equals({_quantity.Name} other, {_quantity.Name} tolerance) instead, to check equality across units and to specify the max tolerance for rounding errors due to floating-point arithmetic when converting between units."")]
-        public bool Equals({_quantity.Name} other, {_quantity.ValueType} tolerance, ComparisonType comparisonType)
+        public bool Equals({_quantity.Name} other, double tolerance, ComparisonType comparisonType)
         {{
             if (tolerance < 0)
                 throw new ArgumentOutOfRangeException(nameof(tolerance), ""Tolerance must be greater than or equal to 0."");
@@ -1009,7 +1000,7 @@ private void GenerateConversionMethods()
         ///     Convert to the unit representation <paramref name=""unit"" />.
         /// </summary>
         /// <returns>Value converted to the specified unit.</returns>
-        public {_quantity.ValueType} As({_unitEnumName} unit)
+        public double As({_unitEnumName} unit)
         {{
             if (Unit == unit)
                 return Value;
@@ -1018,21 +1009,10 @@ private void GenerateConversionMethods()
         }}
 ");
 
-            if (_quantity.ValueType == "decimal")
-            {
-                Writer.WL($@"
-
-        double IQuantity<{_unitEnumName}>.As({_unitEnumName} unit)
-        {{
-            return (double)As(unit);
-        }}
-");
-            }
-
             Writer.WL($@"
 
         /// <inheritdoc cref=""IQuantity.As(UnitSystem)""/>
-        public {_quantity.ValueType} As(UnitSystem unitSystem)
+        public double As(UnitSystem unitSystem)
         {{
             if (unitSystem is null)
                 throw new ArgumentNullException(nameof(unitSystem));
@@ -1047,17 +1027,6 @@ private void GenerateConversionMethods()
         }}
 ");
 
-            if (_quantity.ValueType == "decimal")
-            {
-                Writer.WL($@"
-         /// <inheritdoc cref=""IQuantity.As(UnitSystem)""/>
-        double IQuantity.As(UnitSystem unitSystem)
-        {{
-            return (double)As(unitSystem);
-        }}
-");
-            }
-
             Writer.WL($@"
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
@@ -1065,7 +1034,7 @@ double IQuantity.As(Enum unit)
             if (!(unit is {_unitEnumName} typedUnit))
                 throw new ArgumentException($""The given unit is of type {{unit.GetType()}}. Only {{typeof({_unitEnumName})}} is supported."", nameof(unit));
 
-            return (double)As(typedUnit);
+            return As(typedUnit);
         }}
 
         /// <summary>
diff --git a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
index 5579d69895..6c0b3b9c2c 100644
--- a/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/UnitTestBaseClassGenerator.cs
@@ -40,11 +40,6 @@ internal class UnitTestBaseClassGenerator : GeneratorBase
         /// </summary>
         private readonly string _baseUnitFullName;
 
-        /// <summary>
-        /// Constructors for decimal-backed quantities require decimal numbers as input, so add the "m" suffix to numbers when constructing those quantities.
-        /// </summary>
-        private readonly string _numberSuffix;
-
         /// <summary>
         /// Other unit, if more than one unit exists for quantity, otherwise same as <see cref="_baseUnit"/>.
         /// </summary>
@@ -66,7 +61,6 @@ public UnitTestBaseClassGenerator(Quantity quantity)
 
             _baseUnitEnglishAbbreviation = GetEnglishAbbreviation(_baseUnit);
             _baseUnitFullName = $"{_unitEnumName}.{_baseUnit.SingularName}";
-            _numberSuffix = quantity.ValueType == "decimal" ? "m" : "";
 
             // Try to pick another unit, or fall back to base unit if only a single unit.
             _otherOrBaseUnit = quantity.Units.Where(u => u != _baseUnit).DefaultIfEmpty(_baseUnit).First();
@@ -117,7 +111,7 @@ public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
                 if (unit.SkipConversionGeneration) continue;
 
                 Writer.WL($@"
-        protected abstract {_quantity.ValueType} {unit.PluralName}InOne{_baseUnit.SingularName} {{ get; }}");
+        protected abstract double {unit.PluralName}InOne{_baseUnit.SingularName} {{ get; }}");
             }
 
             Writer.WL();
@@ -128,12 +122,12 @@ public abstract partial class {_quantity.Name}TestsBase : QuantityTestsBase
                 if (unit.SkipConversionGeneration) continue;
 
                 Writer.WL($@"
-        protected virtual {_quantity.ValueType} {unit.PluralName}Tolerance {{ get {{ return { (_quantity.ValueType == "decimal" ? "1e-9m" : "1e-5") }; }} }}");
+        protected virtual double {unit.PluralName}Tolerance {{ get {{ return 1e-5; }} }}");
             }
             Writer.WL($@"
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
-        protected ({_quantity.ValueType} UnitsInBaseUnit, {_quantity.ValueType} Tolerence) GetConversionFactor({_unitEnumName} unit)
+        protected (double UnitsInBaseUnit, double Tolerence) GetConversionFactor({_unitEnumName} unit)
         {{
             return unit switch
             {{");
@@ -165,8 +159,7 @@ public void DefaultCtor_ReturnsQuantityWithZeroValueAndBaseUnit()
             Assert.Equal(0, quantity.Value);
             Assert.Equal({_baseUnitFullName}, quantity.Unit);
         }}
-");
-            if (_quantity.ValueType == "double") Writer.WL($@"
+
         [Fact]
         public void Ctor_WithInfinityValue_DoNotThrowsArgumentException()
         {{
@@ -184,7 +177,6 @@ public void Ctor_WithNaNValue_DoNotThrowsArgumentException()
 
             Assert.Null(exception);
         }}
-"); Writer.WL($@"
 
         [Fact]
         public void Ctor_NullAsUnitSystem_ThrowsArgumentNullException()
@@ -247,8 +239,7 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
             }
             Writer.WL($@"
         }}
-");
-            if (_quantity.ValueType == "double") Writer.WL($@"
+
         [Fact]
         public void From{_baseUnit.PluralName}_WithInfinityValue_DoNotThrowsArgumentException()
         {{
@@ -266,7 +257,6 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
 
             Assert.Null(exception);
         }}
-"); Writer.WL($@"
 
         [Fact]
         public void As()
@@ -518,7 +508,7 @@ public void CompareToThrowsOnNull()
         [InlineData(1, {_baseUnitFullName}, 1, {_otherOrBaseUnitFullName}, false)] // Different unit.");
             }
             Writer.WL($@"
-        public void Equals_ReturnsTrue_IfValueAndUnitAreEqual({_quantity.ValueType} valueA, {_unitEnumName} unitA, {_quantity.ValueType} valueB, {_unitEnumName} unitB, bool expectEqual)
+        public void Equals_ReturnsTrue_IfValueAndUnitAreEqual(double valueA, {_unitEnumName} unitA, double valueB, {_unitEnumName} unitB, bool expectEqual)
         {{
             var a = new {_quantity.Name}(valueA, unitA);
             var b = new {_quantity.Name}(valueB, unitB);
@@ -639,10 +629,10 @@ public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCul
             try
             {{
                 CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
-                Assert.Equal(""0.1{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456{_numberSuffix}, {_baseUnitFullName}).ToString(""s1""));
-                Assert.Equal(""0.12{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456{_numberSuffix}, {_baseUnitFullName}).ToString(""s2""));
-                Assert.Equal(""0.123{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456{_numberSuffix}, {_baseUnitFullName}).ToString(""s3""));
-                Assert.Equal(""0.1235{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456{_numberSuffix}, {_baseUnitFullName}).ToString(""s4""));
+                Assert.Equal(""0.1{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s1""));
+                Assert.Equal(""0.12{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s2""));
+                Assert.Equal(""0.123{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s3""));
+                Assert.Equal(""0.1235{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s4""));
             }}
             finally
             {{
@@ -654,10 +644,10 @@ public void ToString_SFormat_FormatsNumberWithGivenDigitsAfterRadixForCurrentCul
         public void ToString_SFormatAndCulture_FormatsNumberWithGivenDigitsAfterRadixForGivenCulture()
         {{
             var culture = CultureInfo.InvariantCulture;
-            Assert.Equal(""0.1{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456{_numberSuffix}, {_baseUnitFullName}).ToString(""s1"", culture));
-            Assert.Equal(""0.12{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456{_numberSuffix}, {_baseUnitFullName}).ToString(""s2"", culture));
-            Assert.Equal(""0.123{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456{_numberSuffix}, {_baseUnitFullName}).ToString(""s3"", culture));
-            Assert.Equal(""0.1235{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456{_numberSuffix}, {_baseUnitFullName}).ToString(""s4"", culture));
+            Assert.Equal(""0.1{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s1"", culture));
+            Assert.Equal(""0.12{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s2"", culture));
+            Assert.Equal(""0.123{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s3"", culture));
+            Assert.Equal(""0.1235{_baseUnitEnglishAbbreviation}"", new {_quantity.Name}(0.123456, {_baseUnitFullName}).ToString(""s4"", culture));
         }}
 
         [Theory]
diff --git a/CodeGen/JsonTypes/Quantity.cs b/CodeGen/JsonTypes/Quantity.cs
index 6956560161..35f81a3ee2 100644
--- a/CodeGen/JsonTypes/Quantity.cs
+++ b/CodeGen/JsonTypes/Quantity.cs
@@ -11,7 +11,6 @@ internal record Quantity
 #pragma warning disable 0649
 
         public BaseDimensions BaseDimensions = new(); // Default to empty
-        public string ValueType = "double";
         public string BaseUnit = null!;
         public bool GenerateArithmetic = true;
         public bool Logarithmic = false;
diff --git a/CodeGen/PrefixInfo.cs b/CodeGen/PrefixInfo.cs
index 1ec641b3b6..e44c643c48 100644
--- a/CodeGen/PrefixInfo.cs
+++ b/CodeGen/PrefixInfo.cs
@@ -15,9 +15,6 @@ internal class PrefixInfo
 
         public static readonly IReadOnlyDictionary<Prefix, PrefixInfo> Entries = new[]
         {
-            // Need to append 'd' suffix for double in order to later search/replace "d" with "m"
-            // when creating decimal conversion functions in CodeGen.Generator.FixConversionFunctionsForDecimalValueTypes.
-
             // SI prefixes
             new PrefixInfo(Prefix.Yocto, "1e-24d", "y",(Chinese, "夭")),
             new PrefixInfo(Prefix.Zepto, "1e-21d", "z",(Chinese, "仄")),

From 8f655e40510c445d27aa0f2d8680c5da30b5ce95 Mon Sep 17 00:00:00 2001
From: Muximize <Muximize@users.noreply.github.com>
Date: Mon, 19 Feb 2024 17:09:35 +0100
Subject: [PATCH 07/11] Generate code

---
 ...rbedDoseOfIonizingRadiationExtensions.g.cs |  32 +-
 .../NumberToAccelerationExtensions.g.cs       |  28 +-
 .../NumberToAmountOfSubstanceExtensions.g.cs  |  34 +-
 .../NumberToAmplitudeRatioExtensions.g.cs     |   8 +-
 .../NumberToAngleExtensions.g.cs              |  32 +-
 .../NumberToApparentEnergyExtensions.g.cs     |   6 +-
 .../NumberToApparentPowerExtensions.g.cs      |  12 +-
 .../NumberToAreaDensityExtensions.g.cs        |   6 +-
 .../GeneratedCode/NumberToAreaExtensions.g.cs |  28 +-
 ...NumberToAreaMomentOfInertiaExtensions.g.cs |  12 +-
 .../NumberToBitRateExtensions.g.cs            |  52 +--
 ...rakeSpecificFuelConsumptionExtensions.g.cs |   6 +-
 .../NumberToCapacitanceExtensions.g.cs        |  14 +-
 ...efficientOfThermalExpansionExtensions.g.cs |  18 +-
 .../NumberToCompressibilityExtensions.g.cs    |  14 +-
 .../NumberToDensityExtensions.g.cs            | 112 +++---
 .../NumberToDurationExtensions.g.cs           |  22 +-
 .../NumberToDynamicViscosityExtensions.g.cs   |  20 +-
 .../NumberToElectricAdmittanceExtensions.g.cs |   8 +-
 ...mberToElectricChargeDensityExtensions.g.cs |   2 +-
 .../NumberToElectricChargeExtensions.g.cs     |  22 +-
 ...NumberToElectricConductanceExtensions.g.cs |  10 +-
 ...umberToElectricConductivityExtensions.g.cs |  12 +-
 ...berToElectricCurrentDensityExtensions.g.cs |   6 +-
 .../NumberToElectricCurrentExtensions.g.cs    |  18 +-
 ...erToElectricCurrentGradientExtensions.g.cs |  14 +-
 .../NumberToElectricFieldExtensions.g.cs      |   2 +-
 .../NumberToElectricInductanceExtensions.g.cs |  10 +-
 ...NumberToElectricPotentialAcExtensions.g.cs |  10 +-
 ...ElectricPotentialChangeRateExtensions.g.cs |  40 +-
 ...NumberToElectricPotentialDcExtensions.g.cs |  10 +-
 .../NumberToElectricPotentialExtensions.g.cs  |  12 +-
 .../NumberToElectricResistanceExtensions.g.cs |  14 +-
 ...NumberToElectricResistivityExtensions.g.cs |  28 +-
 ...lectricSurfaceChargeDensityExtensions.g.cs |   6 +-
 .../NumberToEnergyDensityExtensions.g.cs      |  24 +-
 .../NumberToEnergyExtensions.g.cs             |  80 ++--
 .../NumberToEntropyExtensions.g.cs            |  14 +-
 .../NumberToForceChangeRateExtensions.g.cs    |  30 +-
 .../NumberToForceExtensions.g.cs              |  30 +-
 .../NumberToForcePerLengthExtensions.g.cs     |  76 ++--
 .../NumberToFrequencyExtensions.g.cs          |  26 +-
 .../NumberToFuelEfficiencyExtensions.g.cs     |   8 +-
 .../NumberToHeatFluxExtensions.g.cs           |  36 +-
 ...erToHeatTransferCoefficientExtensions.g.cs |  12 +-
 .../NumberToIlluminanceExtensions.g.cs        |   8 +-
 .../NumberToImpulseExtensions.g.cs            |  26 +-
 .../NumberToInformationExtensions.g.cs        |  52 +--
 .../NumberToIrradianceExtensions.g.cs         |  28 +-
 .../NumberToIrradiationExtensions.g.cs        |  14 +-
 .../GeneratedCode/NumberToJerkExtensions.g.cs |  22 +-
 .../NumberToKinematicViscosityExtensions.g.cs |  18 +-
 .../NumberToLeakRateExtensions.g.cs           |   6 +-
 .../NumberToLengthExtensions.g.cs             |  84 ++--
 .../NumberToLevelExtensions.g.cs              |   4 +-
 .../NumberToLinearDensityExtensions.g.cs      |  28 +-
 .../NumberToLinearPowerDensityExtensions.g.cs |  50 +--
 .../NumberToLuminanceExtensions.g.cs          |  20 +-
 .../NumberToLuminosityExtensions.g.cs         |  28 +-
 .../NumberToLuminousFluxExtensions.g.cs       |   2 +-
 .../NumberToLuminousIntensityExtensions.g.cs  |   2 +-
 .../NumberToMagneticFieldExtensions.g.cs      |  12 +-
 .../NumberToMagneticFluxExtensions.g.cs       |   2 +-
 .../NumberToMagnetizationExtensions.g.cs      |   2 +-
 .../NumberToMassConcentrationExtensions.g.cs  |  98 ++---
 .../GeneratedCode/NumberToMassExtensions.g.cs |  54 +--
 .../NumberToMassFlowExtensions.g.cs           |  66 ++--
 .../NumberToMassFluxExtensions.g.cs           |  24 +-
 .../NumberToMassFractionExtensions.g.cs       |  48 +--
 ...NumberToMassMomentOfInertiaExtensions.g.cs |  56 +--
 .../NumberToMolalityExtensions.g.cs           |   4 +-
 .../NumberToMolarEnergyExtensions.g.cs        |   6 +-
 .../NumberToMolarEntropyExtensions.g.cs       |   6 +-
 .../NumberToMolarFlowExtensions.g.cs          |  18 +-
 .../NumberToMolarMassExtensions.g.cs          |  26 +-
 .../NumberToMolarityExtensions.g.cs           |  22 +-
 .../NumberToPermeabilityExtensions.g.cs       |   2 +-
 .../NumberToPermittivityExtensions.g.cs       |   2 +-
 ...rToPorousMediumPermeabilityExtensions.g.cs |  10 +-
 .../NumberToPowerDensityExtensions.g.cs       |  88 ++---
 .../NumberToPowerExtensions.g.cs              |  52 +--
 .../NumberToPowerRatioExtensions.g.cs         |   4 +-
 .../NumberToPressureChangeRateExtensions.g.cs |  36 +-
 .../NumberToPressureExtensions.g.cs           |  98 ++---
 .../NumberToRadiationExposureExtensions.g.cs  |  16 +-
 .../NumberToRadioactivityExtensions.g.cs      |  58 +--
 .../NumberToRatioChangeRateExtensions.g.cs    |   4 +-
 .../NumberToRatioExtensions.g.cs              |  12 +-
 .../NumberToReactiveEnergyExtensions.g.cs     |   6 +-
 .../NumberToReactivePowerExtensions.g.cs      |   8 +-
 .../NumberToReciprocalAreaExtensions.g.cs     |  22 +-
 .../NumberToReciprocalLengthExtensions.g.cs   |  20 +-
 .../NumberToRelativeHumidityExtensions.g.cs   |   2 +-
 ...berToRotationalAccelerationExtensions.g.cs |   8 +-
 .../NumberToRotationalSpeedExtensions.g.cs    |  26 +-
 ...NumberToRotationalStiffnessExtensions.g.cs |  66 ++--
 ...otationalStiffnessPerLengthExtensions.g.cs |  10 +-
 .../NumberToScalarExtensions.g.cs             |   2 +-
 .../NumberToSolidAngleExtensions.g.cs         |   2 +-
 .../NumberToSpecificEnergyExtensions.g.cs     |  60 +--
 .../NumberToSpecificEntropyExtensions.g.cs    |  18 +-
 ...erToSpecificFuelConsumptionExtensions.g.cs |   8 +-
 .../NumberToSpecificVolumeExtensions.g.cs     |   6 +-
 .../NumberToSpecificWeightExtensions.g.cs     |  34 +-
 .../NumberToSpeedExtensions.g.cs              |  66 ++--
 .../NumberToStandardVolumeFlowExtensions.g.cs |  18 +-
 ...mberToTemperatureChangeRateExtensions.g.cs |  20 +-
 .../NumberToTemperatureDeltaExtensions.g.cs   |  18 +-
 .../NumberToTemperatureExtensions.g.cs        |  20 +-
 ...NumberToTemperatureGradientExtensions.g.cs |   8 +-
 ...NumberToThermalConductivityExtensions.g.cs |   4 +-
 .../NumberToThermalResistanceExtensions.g.cs  |  12 +-
 .../NumberToTorqueExtensions.g.cs             |  50 +--
 .../NumberToTorquePerLengthExtensions.g.cs    |  42 +-
 .../NumberToTurbidityExtensions.g.cs          |   2 +-
 .../NumberToVitaminAExtensions.g.cs           |   2 +-
 ...NumberToVolumeConcentrationExtensions.g.cs |  40 +-
 .../NumberToVolumeExtensions.g.cs             | 108 +++---
 .../NumberToVolumeFlowExtensions.g.cs         | 134 +++----
 .../NumberToVolumeFlowPerAreaExtensions.g.cs  |   4 +-
 .../NumberToVolumePerLengthExtensions.g.cs    |  18 +-
 ...berToVolumetricHeatCapacityExtensions.g.cs |  18 +-
 ...berToWarpingMomentOfInertiaExtensions.g.cs |  12 +-
 .../AbsorbedDoseOfIonizingRadiation.g.cs      | 109 ++----
 .../Quantities/Acceleration.g.cs              |  99 ++---
 .../Quantities/AmountOfSubstance.g.cs         | 114 ++----
 .../Quantities/AmplitudeRatio.g.cs            |  53 +--
 UnitsNet/GeneratedCode/Quantities/Angle.g.cs  | 109 ++----
 .../Quantities/ApparentEnergy.g.cs            |  44 +--
 .../Quantities/ApparentPower.g.cs             |  59 +--
 UnitsNet/GeneratedCode/Quantities/Area.g.cs   |  99 ++---
 .../GeneratedCode/Quantities/AreaDensity.g.cs |  44 +--
 .../Quantities/AreaMomentOfInertia.g.cs       |  59 +--
 .../GeneratedCode/Quantities/BitRate.g.cs     | 159 +++-----
 .../BrakeSpecificFuelConsumption.g.cs         |  44 +--
 .../GeneratedCode/Quantities/Capacitance.g.cs |  64 +--
 .../CoefficientOfThermalExpansion.g.cs        |  74 ++--
 .../Quantities/Compressibility.g.cs           |  64 +--
 .../GeneratedCode/Quantities/Density.g.cs     | 309 ++++++---------
 .../GeneratedCode/Quantities/Duration.g.cs    |  84 ++--
 .../Quantities/DynamicViscosity.g.cs          |  79 ++--
 .../Quantities/ElectricAdmittance.g.cs        |  49 +--
 .../Quantities/ElectricCharge.g.cs            |  84 ++--
 .../Quantities/ElectricChargeDensity.g.cs     |  34 +-
 .../Quantities/ElectricConductance.g.cs       |  54 +--
 .../Quantities/ElectricConductivity.g.cs      |  59 +--
 .../Quantities/ElectricCurrent.g.cs           |  74 ++--
 .../Quantities/ElectricCurrentDensity.g.cs    |  44 +--
 .../Quantities/ElectricCurrentGradient.g.cs   |  64 +--
 .../Quantities/ElectricField.g.cs             |  34 +-
 .../Quantities/ElectricInductance.g.cs        |  54 +--
 .../Quantities/ElectricPotential.g.cs         |  59 +--
 .../Quantities/ElectricPotentialAc.g.cs       |  54 +--
 .../ElectricPotentialChangeRate.g.cs          | 129 +++----
 .../Quantities/ElectricPotentialDc.g.cs       |  54 +--
 .../Quantities/ElectricResistance.g.cs        |  64 +--
 .../Quantities/ElectricResistivity.g.cs       |  99 ++---
 .../ElectricSurfaceChargeDensity.g.cs         |  44 +--
 UnitsNet/GeneratedCode/Quantities/Energy.g.cs | 229 ++++-------
 .../Quantities/EnergyDensity.g.cs             |  89 ++---
 .../GeneratedCode/Quantities/Entropy.g.cs     |  64 +--
 UnitsNet/GeneratedCode/Quantities/Force.g.cs  | 104 ++---
 .../Quantities/ForceChangeRate.g.cs           | 104 ++---
 .../Quantities/ForcePerLength.g.cs            | 219 ++++-------
 .../GeneratedCode/Quantities/Frequency.g.cs   |  94 ++---
 .../Quantities/FuelEfficiency.g.cs            |  49 +--
 .../GeneratedCode/Quantities/HeatFlux.g.cs    | 119 ++----
 .../Quantities/HeatTransferCoefficient.g.cs   |  59 +--
 .../GeneratedCode/Quantities/Illuminance.g.cs |  49 +--
 .../GeneratedCode/Quantities/Impulse.g.cs     |  94 ++---
 .../GeneratedCode/Quantities/Information.g.cs | 159 +++-----
 .../GeneratedCode/Quantities/Irradiance.g.cs  |  99 ++---
 .../GeneratedCode/Quantities/Irradiation.g.cs |  64 +--
 UnitsNet/GeneratedCode/Quantities/Jerk.g.cs   |  84 ++--
 .../Quantities/KinematicViscosity.g.cs        |  74 ++--
 .../GeneratedCode/Quantities/LeakRate.g.cs    |  44 +--
 UnitsNet/GeneratedCode/Quantities/Length.g.cs | 239 +++++-------
 UnitsNet/GeneratedCode/Quantities/Level.g.cs  |  43 +--
 .../Quantities/LinearDensity.g.cs             |  99 ++---
 .../Quantities/LinearPowerDensity.g.cs        | 154 +++-----
 .../GeneratedCode/Quantities/Luminance.g.cs   |  79 ++--
 .../GeneratedCode/Quantities/Luminosity.g.cs  |  99 ++---
 .../Quantities/LuminousFlux.g.cs              |  34 +-
 .../Quantities/LuminousIntensity.g.cs         |  34 +-
 .../Quantities/MagneticField.g.cs             |  59 +--
 .../Quantities/MagneticFlux.g.cs              |  34 +-
 .../Quantities/Magnetization.g.cs             |  34 +-
 UnitsNet/GeneratedCode/Quantities/Mass.g.cs   | 164 +++-----
 .../Quantities/MassConcentration.g.cs         | 274 +++++--------
 .../GeneratedCode/Quantities/MassFlow.g.cs    | 194 ++++------
 .../GeneratedCode/Quantities/MassFlux.g.cs    |  89 ++---
 .../Quantities/MassFraction.g.cs              | 149 +++----
 .../Quantities/MassMomentOfInertia.g.cs       | 169 +++-----
 .../GeneratedCode/Quantities/Molality.g.cs    |  39 +-
 .../GeneratedCode/Quantities/MolarEnergy.g.cs |  44 +--
 .../Quantities/MolarEntropy.g.cs              |  44 +--
 .../GeneratedCode/Quantities/MolarFlow.g.cs   |  74 ++--
 .../GeneratedCode/Quantities/MolarMass.g.cs   |  94 ++---
 .../GeneratedCode/Quantities/Molarity.g.cs    |  84 ++--
 .../Quantities/Permeability.g.cs              |  34 +-
 .../Quantities/Permittivity.g.cs              |  34 +-
 .../Quantities/PorousMediumPermeability.g.cs  |  54 +--
 UnitsNet/GeneratedCode/Quantities/Power.g.cs  | 159 +++-----
 .../Quantities/PowerDensity.g.cs              | 249 +++++-------
 .../GeneratedCode/Quantities/PowerRatio.g.cs  |  43 +--
 .../GeneratedCode/Quantities/Pressure.g.cs    | 274 +++++--------
 .../Quantities/PressureChangeRate.g.cs        | 119 ++----
 .../Quantities/RadiationExposure.g.cs         |  69 +---
 .../Quantities/Radioactivity.g.cs             | 174 +++------
 UnitsNet/GeneratedCode/Quantities/Ratio.g.cs  |  59 +--
 .../Quantities/RatioChangeRate.g.cs           |  39 +-
 .../Quantities/ReactiveEnergy.g.cs            |  44 +--
 .../Quantities/ReactivePower.g.cs             |  49 +--
 .../Quantities/ReciprocalArea.g.cs            |  84 ++--
 .../Quantities/ReciprocalLength.g.cs          |  79 ++--
 .../Quantities/RelativeHumidity.g.cs          |  34 +-
 .../Quantities/RotationalAcceleration.g.cs    |  49 +--
 .../Quantities/RotationalSpeed.g.cs           |  94 ++---
 .../Quantities/RotationalStiffness.g.cs       | 194 ++++------
 .../RotationalStiffnessPerLength.g.cs         |  54 +--
 UnitsNet/GeneratedCode/Quantities/Scalar.g.cs |  34 +-
 .../GeneratedCode/Quantities/SolidAngle.g.cs  |  34 +-
 .../Quantities/SpecificEnergy.g.cs            | 179 +++------
 .../Quantities/SpecificEntropy.g.cs           |  74 ++--
 .../Quantities/SpecificFuelConsumption.g.cs   |  49 +--
 .../Quantities/SpecificVolume.g.cs            |  44 +--
 .../Quantities/SpecificWeight.g.cs            | 114 ++----
 UnitsNet/GeneratedCode/Quantities/Speed.g.cs  | 194 ++++------
 .../Quantities/StandardVolumeFlow.g.cs        |  74 ++--
 .../GeneratedCode/Quantities/Temperature.g.cs |  79 ++--
 .../Quantities/TemperatureChangeRate.g.cs     |  79 ++--
 .../Quantities/TemperatureDelta.g.cs          |  74 ++--
 .../Quantities/TemperatureGradient.g.cs       |  49 +--
 .../Quantities/ThermalConductivity.g.cs       |  39 +-
 .../Quantities/ThermalResistance.g.cs         |  59 +--
 UnitsNet/GeneratedCode/Quantities/Torque.g.cs | 154 +++-----
 .../Quantities/TorquePerLength.g.cs           | 134 +++----
 .../GeneratedCode/Quantities/Turbidity.g.cs   |  34 +-
 .../GeneratedCode/Quantities/VitaminA.g.cs    |  34 +-
 UnitsNet/GeneratedCode/Quantities/Volume.g.cs | 299 ++++++--------
 .../Quantities/VolumeConcentration.g.cs       | 129 +++----
 .../GeneratedCode/Quantities/VolumeFlow.g.cs  | 364 +++++++-----------
 .../Quantities/VolumeFlowPerArea.g.cs         |  39 +-
 .../Quantities/VolumePerLength.g.cs           |  74 ++--
 .../Quantities/VolumetricHeatCapacity.g.cs    |  74 ++--
 .../Quantities/WarpingMomentOfInertia.g.cs    |  59 +--
 UnitsNet/GeneratedCode/Quantity.g.cs          |   4 +-
 247 files changed, 5192 insertions(+), 9339 deletions(-)

diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
index c4dc4f6742..8011ae4fef 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAbsorbedDoseOfIonizingRadiationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToAbsorbedDoseOfIonizingRadiation
     /// </summary>
     public static class NumberToAbsorbedDoseOfIonizingRadiationExtensions
     {
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromCentigrays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromCentigrays(double)" />
         public static AbsorbedDoseOfIonizingRadiation Centigrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static AbsorbedDoseOfIonizingRadiation Centigrays<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromCentigrays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromFemtograys(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromFemtograys(double)" />
         public static AbsorbedDoseOfIonizingRadiation Femtograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static AbsorbedDoseOfIonizingRadiation Femtograys<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromFemtograys(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGigagrays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGigagrays(double)" />
         public static AbsorbedDoseOfIonizingRadiation Gigagrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static AbsorbedDoseOfIonizingRadiation Gigagrays<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromGigagrays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGrays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromGrays(double)" />
         public static AbsorbedDoseOfIonizingRadiation Grays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static AbsorbedDoseOfIonizingRadiation Grays<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromGrays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilograys(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilograys(double)" />
         public static AbsorbedDoseOfIonizingRadiation Kilograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static AbsorbedDoseOfIonizingRadiation Kilograys<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromKilograys(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilorads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromKilorads(double)" />
         public static AbsorbedDoseOfIonizingRadiation Kilorads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static AbsorbedDoseOfIonizingRadiation Kilorads<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromKilorads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegagrays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegagrays(double)" />
         public static AbsorbedDoseOfIonizingRadiation Megagrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static AbsorbedDoseOfIonizingRadiation Megagrays<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromMegagrays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegarads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMegarads(double)" />
         public static AbsorbedDoseOfIonizingRadiation Megarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static AbsorbedDoseOfIonizingRadiation Megarads<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromMegarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMicrograys(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMicrograys(double)" />
         public static AbsorbedDoseOfIonizingRadiation Micrograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static AbsorbedDoseOfIonizingRadiation Micrograys<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromMicrograys(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMilligrays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMilligrays(double)" />
         public static AbsorbedDoseOfIonizingRadiation Milligrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static AbsorbedDoseOfIonizingRadiation Milligrays<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromMilligrays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMillirads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromMillirads(double)" />
         public static AbsorbedDoseOfIonizingRadiation Millirads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static AbsorbedDoseOfIonizingRadiation Millirads<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromMillirads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromNanograys(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromNanograys(double)" />
         public static AbsorbedDoseOfIonizingRadiation Nanograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static AbsorbedDoseOfIonizingRadiation Nanograys<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromNanograys(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPetagrays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPetagrays(double)" />
         public static AbsorbedDoseOfIonizingRadiation Petagrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static AbsorbedDoseOfIonizingRadiation Petagrays<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromPetagrays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPicograys(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromPicograys(double)" />
         public static AbsorbedDoseOfIonizingRadiation Picograys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static AbsorbedDoseOfIonizingRadiation Picograys<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromPicograys(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromRads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromRads(double)" />
         public static AbsorbedDoseOfIonizingRadiation Rads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static AbsorbedDoseOfIonizingRadiation Rads<T>(this T value)
 #endif
             => AbsorbedDoseOfIonizingRadiation.FromRads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromTeragrays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AbsorbedDoseOfIonizingRadiation.FromTeragrays(double)" />
         public static AbsorbedDoseOfIonizingRadiation Teragrays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
index 169625ebe9..53301e4bef 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAccelerationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToAcceleration
     /// </summary>
     public static class NumberToAccelerationExtensions
     {
-        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double)" />
         public static Acceleration CentimetersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Acceleration CentimetersPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromCentimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double)" />
         public static Acceleration DecimetersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Acceleration DecimetersPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromDecimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromFeetPerSecondSquared(double)" />
         public static Acceleration FeetPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Acceleration FeetPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromFeetPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromInchesPerSecondSquared(double)" />
         public static Acceleration InchesPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Acceleration InchesPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromInchesPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double)" />
         public static Acceleration KilometersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Acceleration KilometersPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromKilometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromKnotsPerHour(double)" />
         public static Acceleration KnotsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Acceleration KnotsPerHour<T>(this T value)
 #endif
             => Acceleration.FromKnotsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromKnotsPerMinute(double)" />
         public static Acceleration KnotsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Acceleration KnotsPerMinute<T>(this T value)
 #endif
             => Acceleration.FromKnotsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromKnotsPerSecond(double)" />
         public static Acceleration KnotsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Acceleration KnotsPerSecond<T>(this T value)
 #endif
             => Acceleration.FromKnotsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double)" />
         public static Acceleration MetersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Acceleration MetersPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromMetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double)" />
         public static Acceleration MicrometersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Acceleration MicrometersPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromMicrometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double)" />
         public static Acceleration MillimetersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Acceleration MillimetersPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromMillimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMillistandardGravity(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromMillistandardGravity(double)" />
         public static Acceleration MillistandardGravity<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Acceleration MillistandardGravity<T>(this T value)
 #endif
             => Acceleration.FromMillistandardGravity(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double)" />
         public static Acceleration NanometersPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Acceleration NanometersPerSecondSquared<T>(this T value)
 #endif
             => Acceleration.FromNanometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromStandardGravity(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Acceleration.FromStandardGravity(double)" />
         public static Acceleration StandardGravity<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
index 25fc55c494..4993b43931 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmountOfSubstanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToAmountOfSubstance
     /// </summary>
     public static class NumberToAmountOfSubstanceExtensions
     {
-        /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromCentimoles(double)" />
         public static AmountOfSubstance Centimoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static AmountOfSubstance Centimoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromCentimoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromCentipoundMoles(double)" />
         public static AmountOfSubstance CentipoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static AmountOfSubstance CentipoundMoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromCentipoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromDecimoles(double)" />
         public static AmountOfSubstance Decimoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static AmountOfSubstance Decimoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromDecimoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromDecipoundMoles(double)" />
         public static AmountOfSubstance DecipoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static AmountOfSubstance DecipoundMoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromDecipoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromFemtomoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromFemtomoles(double)" />
         public static AmountOfSubstance Femtomoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static AmountOfSubstance Femtomoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromFemtomoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromKilomoles(double)" />
         public static AmountOfSubstance Kilomoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static AmountOfSubstance Kilomoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromKilomoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromKilopoundMoles(double)" />
         public static AmountOfSubstance KilopoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static AmountOfSubstance KilopoundMoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromKilopoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMegamoles(double)" />
         public static AmountOfSubstance Megamoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static AmountOfSubstance Megamoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromMegamoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMicromoles(double)" />
         public static AmountOfSubstance Micromoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static AmountOfSubstance Micromoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromMicromoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMicropoundMoles(double)" />
         public static AmountOfSubstance MicropoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static AmountOfSubstance MicropoundMoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromMicropoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMillimoles(double)" />
         public static AmountOfSubstance Millimoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static AmountOfSubstance Millimoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromMillimoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMillipoundMoles(double)" />
         public static AmountOfSubstance MillipoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static AmountOfSubstance MillipoundMoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromMillipoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromMoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromMoles(double)" />
         public static AmountOfSubstance Moles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static AmountOfSubstance Moles<T>(this T value)
 #endif
             => AmountOfSubstance.FromMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromNanomoles(double)" />
         public static AmountOfSubstance Nanomoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static AmountOfSubstance Nanomoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromNanomoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromNanopoundMoles(double)" />
         public static AmountOfSubstance NanopoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static AmountOfSubstance NanopoundMoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromNanopoundMoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromPicomoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromPicomoles(double)" />
         public static AmountOfSubstance Picomoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static AmountOfSubstance Picomoles<T>(this T value)
 #endif
             => AmountOfSubstance.FromPicomoles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmountOfSubstance.FromPoundMoles(double)" />
         public static AmountOfSubstance PoundMoles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
index 1f3d3ae750..778ee3b019 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAmplitudeRatioExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToAmplitudeRatio
     /// </summary>
     public static class NumberToAmplitudeRatioExtensions
     {
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMicrovolts(double)" />
         public static AmplitudeRatio DecibelMicrovolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static AmplitudeRatio DecibelMicrovolts<T>(this T value)
 #endif
             => AmplitudeRatio.FromDecibelMicrovolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelMillivolts(double)" />
         public static AmplitudeRatio DecibelMillivolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static AmplitudeRatio DecibelMillivolts<T>(this T value)
 #endif
             => AmplitudeRatio.FromDecibelMillivolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelsUnloaded(double)" />
         public static AmplitudeRatio DecibelsUnloaded<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static AmplitudeRatio DecibelsUnloaded<T>(this T value)
 #endif
             => AmplitudeRatio.FromDecibelsUnloaded(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AmplitudeRatio.FromDecibelVolts(double)" />
         public static AmplitudeRatio DecibelVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
index 947e4fc504..538044922c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAngleExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToAngle
     /// </summary>
     public static class NumberToAngleExtensions
     {
-        /// <inheritdoc cref="Angle.FromArcminutes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromArcminutes(double)" />
         public static Angle Arcminutes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Angle Arcminutes<T>(this T value)
 #endif
             => Angle.FromArcminutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromArcseconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromArcseconds(double)" />
         public static Angle Arcseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Angle Arcseconds<T>(this T value)
 #endif
             => Angle.FromArcseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromCentiradians(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromCentiradians(double)" />
         public static Angle Centiradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Angle Centiradians<T>(this T value)
 #endif
             => Angle.FromCentiradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromDeciradians(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromDeciradians(double)" />
         public static Angle Deciradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Angle Deciradians<T>(this T value)
 #endif
             => Angle.FromDeciradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromDegrees(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromDegrees(double)" />
         public static Angle Degrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Angle Degrees<T>(this T value)
 #endif
             => Angle.FromDegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromGradians(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromGradians(double)" />
         public static Angle Gradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Angle Gradians<T>(this T value)
 #endif
             => Angle.FromGradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromMicrodegrees(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromMicrodegrees(double)" />
         public static Angle Microdegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Angle Microdegrees<T>(this T value)
 #endif
             => Angle.FromMicrodegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromMicroradians(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromMicroradians(double)" />
         public static Angle Microradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Angle Microradians<T>(this T value)
 #endif
             => Angle.FromMicroradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromMillidegrees(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromMillidegrees(double)" />
         public static Angle Millidegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Angle Millidegrees<T>(this T value)
 #endif
             => Angle.FromMillidegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromMilliradians(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromMilliradians(double)" />
         public static Angle Milliradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Angle Milliradians<T>(this T value)
 #endif
             => Angle.FromMilliradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromNanodegrees(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromNanodegrees(double)" />
         public static Angle Nanodegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Angle Nanodegrees<T>(this T value)
 #endif
             => Angle.FromNanodegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromNanoradians(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromNanoradians(double)" />
         public static Angle Nanoradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Angle Nanoradians<T>(this T value)
 #endif
             => Angle.FromNanoradians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromNatoMils(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromNatoMils(double)" />
         public static Angle NatoMils<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Angle NatoMils<T>(this T value)
 #endif
             => Angle.FromNatoMils(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromRadians(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromRadians(double)" />
         public static Angle Radians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Angle Radians<T>(this T value)
 #endif
             => Angle.FromRadians(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromRevolutions(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromRevolutions(double)" />
         public static Angle Revolutions<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Angle Revolutions<T>(this T value)
 #endif
             => Angle.FromRevolutions(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Angle.FromTilt(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Angle.FromTilt(double)" />
         public static Angle Tilt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
index 9d22f10bd9..4f5e9aa218 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentEnergyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToApparentEnergy
     /// </summary>
     public static class NumberToApparentEnergyExtensions
     {
-        /// <inheritdoc cref="ApparentEnergy.FromKilovoltampereHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentEnergy.FromKilovoltampereHours(double)" />
         public static ApparentEnergy KilovoltampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ApparentEnergy KilovoltampereHours<T>(this T value)
 #endif
             => ApparentEnergy.FromKilovoltampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentEnergy.FromMegavoltampereHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentEnergy.FromMegavoltampereHours(double)" />
         public static ApparentEnergy MegavoltampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ApparentEnergy MegavoltampereHours<T>(this T value)
 #endif
             => ApparentEnergy.FromMegavoltampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentEnergy.FromVoltampereHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentEnergy.FromVoltampereHours(double)" />
         public static ApparentEnergy VoltampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
index 9cf9e6ed71..7fb405d7e3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToApparentPowerExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToApparentPower
     /// </summary>
     public static class NumberToApparentPowerExtensions
     {
-        /// <inheritdoc cref="ApparentPower.FromGigavoltamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentPower.FromGigavoltamperes(double)" />
         public static ApparentPower Gigavoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ApparentPower Gigavoltamperes<T>(this T value)
 #endif
             => ApparentPower.FromGigavoltamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentPower.FromKilovoltamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentPower.FromKilovoltamperes(double)" />
         public static ApparentPower Kilovoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ApparentPower Kilovoltamperes<T>(this T value)
 #endif
             => ApparentPower.FromKilovoltamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentPower.FromMegavoltamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentPower.FromMegavoltamperes(double)" />
         public static ApparentPower Megavoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ApparentPower Megavoltamperes<T>(this T value)
 #endif
             => ApparentPower.FromMegavoltamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentPower.FromMicrovoltamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentPower.FromMicrovoltamperes(double)" />
         public static ApparentPower Microvoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ApparentPower Microvoltamperes<T>(this T value)
 #endif
             => ApparentPower.FromMicrovoltamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentPower.FromMillivoltamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentPower.FromMillivoltamperes(double)" />
         public static ApparentPower Millivoltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ApparentPower Millivoltamperes<T>(this T value)
 #endif
             => ApparentPower.FromMillivoltamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ApparentPower.FromVoltamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ApparentPower.FromVoltamperes(double)" />
         public static ApparentPower Voltamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
index fa13776c9c..ad2a5a212a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToAreaDensity
     /// </summary>
     public static class NumberToAreaDensityExtensions
     {
-        /// <inheritdoc cref="AreaDensity.FromGramsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaDensity.FromGramsPerSquareMeter(double)" />
         public static AreaDensity GramsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static AreaDensity GramsPerSquareMeter<T>(this T value)
 #endif
             => AreaDensity.FromGramsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaDensity.FromKilogramsPerSquareMeter(double)" />
         public static AreaDensity KilogramsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static AreaDensity KilogramsPerSquareMeter<T>(this T value)
 #endif
             => AreaDensity.FromKilogramsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaDensity.FromMilligramsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaDensity.FromMilligramsPerSquareMeter(double)" />
         public static AreaDensity MilligramsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
index 8669dd728a..11c81e72b1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToArea
     /// </summary>
     public static class NumberToAreaExtensions
     {
-        /// <inheritdoc cref="Area.FromAcres(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromAcres(double)" />
         public static Area Acres<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Area Acres<T>(this T value)
 #endif
             => Area.FromAcres(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromHectares(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromHectares(double)" />
         public static Area Hectares<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Area Hectares<T>(this T value)
 #endif
             => Area.FromHectares(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareCentimeters(double)" />
         public static Area SquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Area SquareCentimeters<T>(this T value)
 #endif
             => Area.FromSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareDecimeters(double)" />
         public static Area SquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Area SquareDecimeters<T>(this T value)
 #endif
             => Area.FromSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareFeet(double)" />
         public static Area SquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Area SquareFeet<T>(this T value)
 #endif
             => Area.FromSquareFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareInches(double)" />
         public static Area SquareInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Area SquareInches<T>(this T value)
 #endif
             => Area.FromSquareInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareKilometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareKilometers(double)" />
         public static Area SquareKilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Area SquareKilometers<T>(this T value)
 #endif
             => Area.FromSquareKilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareMeters(double)" />
         public static Area SquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Area SquareMeters<T>(this T value)
 #endif
             => Area.FromSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareMicrometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareMicrometers(double)" />
         public static Area SquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Area SquareMicrometers<T>(this T value)
 #endif
             => Area.FromSquareMicrometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareMiles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareMiles(double)" />
         public static Area SquareMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Area SquareMiles<T>(this T value)
 #endif
             => Area.FromSquareMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareMillimeters(double)" />
         public static Area SquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Area SquareMillimeters<T>(this T value)
 #endif
             => Area.FromSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareNauticalMiles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareNauticalMiles(double)" />
         public static Area SquareNauticalMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Area SquareNauticalMiles<T>(this T value)
 #endif
             => Area.FromSquareNauticalMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromSquareYards(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromSquareYards(double)" />
         public static Area SquareYards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Area SquareYards<T>(this T value)
 #endif
             => Area.FromSquareYards(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Area.FromUsSurveySquareFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Area.FromUsSurveySquareFeet(double)" />
         public static Area UsSurveySquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
index 7835b4d707..09807623e6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToAreaMomentOfInertiaExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToAreaMomentOfInertia
     /// </summary>
     public static class NumberToAreaMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromCentimetersToTheFourth(double)" />
         public static AreaMomentOfInertia CentimetersToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static AreaMomentOfInertia CentimetersToTheFourth<T>(this T value)
 #endif
             => AreaMomentOfInertia.FromCentimetersToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromDecimetersToTheFourth(double)" />
         public static AreaMomentOfInertia DecimetersToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static AreaMomentOfInertia DecimetersToTheFourth<T>(this T value)
 #endif
             => AreaMomentOfInertia.FromDecimetersToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromFeetToTheFourth(double)" />
         public static AreaMomentOfInertia FeetToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static AreaMomentOfInertia FeetToTheFourth<T>(this T value)
 #endif
             => AreaMomentOfInertia.FromFeetToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromInchesToTheFourth(double)" />
         public static AreaMomentOfInertia InchesToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static AreaMomentOfInertia InchesToTheFourth<T>(this T value)
 #endif
             => AreaMomentOfInertia.FromInchesToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromMetersToTheFourth(double)" />
         public static AreaMomentOfInertia MetersToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static AreaMomentOfInertia MetersToTheFourth<T>(this T value)
 #endif
             => AreaMomentOfInertia.FromMetersToTheFourth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="AreaMomentOfInertia.FromMillimetersToTheFourth(double)" />
         public static AreaMomentOfInertia MillimetersToTheFourth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
index bdc4de545f..2f85da9ccc 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBitRateExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToBitRate
     /// </summary>
     public static class NumberToBitRateExtensions
     {
-        /// <inheritdoc cref="BitRate.FromBitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromBitsPerSecond(double)" />
         public static BitRate BitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static BitRate BitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromBitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromBytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromBytesPerSecond(double)" />
         public static BitRate BytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static BitRate BytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromBytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromExabitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromExabitsPerSecond(double)" />
         public static BitRate ExabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static BitRate ExabitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromExabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromExabytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromExabytesPerSecond(double)" />
         public static BitRate ExabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static BitRate ExabytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromExabytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromExbibitsPerSecond(double)" />
         public static BitRate ExbibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static BitRate ExbibitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromExbibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromExbibytesPerSecond(double)" />
         public static BitRate ExbibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static BitRate ExbibytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromExbibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromGibibitsPerSecond(double)" />
         public static BitRate GibibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static BitRate GibibitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromGibibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromGibibytesPerSecond(double)" />
         public static BitRate GibibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static BitRate GibibytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromGibibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromGigabitsPerSecond(double)" />
         public static BitRate GigabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static BitRate GigabitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromGigabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromGigabytesPerSecond(double)" />
         public static BitRate GigabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static BitRate GigabytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromGigabytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromKibibitsPerSecond(double)" />
         public static BitRate KibibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static BitRate KibibitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromKibibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromKibibytesPerSecond(double)" />
         public static BitRate KibibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static BitRate KibibytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromKibibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromKilobitsPerSecond(double)" />
         public static BitRate KilobitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static BitRate KilobitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromKilobitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromKilobytesPerSecond(double)" />
         public static BitRate KilobytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static BitRate KilobytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromKilobytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromMebibitsPerSecond(double)" />
         public static BitRate MebibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static BitRate MebibitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromMebibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromMebibytesPerSecond(double)" />
         public static BitRate MebibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static BitRate MebibytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromMebibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromMegabitsPerSecond(double)" />
         public static BitRate MegabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static BitRate MegabitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromMegabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromMegabytesPerSecond(double)" />
         public static BitRate MegabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static BitRate MegabytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromMegabytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromPebibitsPerSecond(double)" />
         public static BitRate PebibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static BitRate PebibitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromPebibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromPebibytesPerSecond(double)" />
         public static BitRate PebibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static BitRate PebibytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromPebibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromPetabitsPerSecond(double)" />
         public static BitRate PetabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static BitRate PetabitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromPetabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromPetabytesPerSecond(double)" />
         public static BitRate PetabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static BitRate PetabytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromPetabytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromTebibitsPerSecond(double)" />
         public static BitRate TebibitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static BitRate TebibitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromTebibitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromTebibytesPerSecond(double)" />
         public static BitRate TebibytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static BitRate TebibytesPerSecond<T>(this T value)
 #endif
             => BitRate.FromTebibytesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromTerabitsPerSecond(double)" />
         public static BitRate TerabitsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static BitRate TerabitsPerSecond<T>(this T value)
 #endif
             => BitRate.FromTerabitsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BitRate.FromTerabytesPerSecond(double)" />
         public static BitRate TerabytesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
index 1eb91c5977..bfffa5835f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToBrakeSpecificFuelConsumptionExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToBrakeSpecificFuelConsumption
     /// </summary>
     public static class NumberToBrakeSpecificFuelConsumptionExtensions
     {
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(double)" />
         public static BrakeSpecificFuelConsumption GramsPerKiloWattHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static BrakeSpecificFuelConsumption GramsPerKiloWattHour<T>(this T value)
 #endif
             => BrakeSpecificFuelConsumption.FromGramsPerKiloWattHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromKilogramsPerJoule(double)" />
         public static BrakeSpecificFuelConsumption KilogramsPerJoule<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static BrakeSpecificFuelConsumption KilogramsPerJoule<T>(this T value)
 #endif
             => BrakeSpecificFuelConsumption.FromKilogramsPerJoule(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="BrakeSpecificFuelConsumption.FromPoundsPerMechanicalHorsepowerHour(double)" />
         public static BrakeSpecificFuelConsumption PoundsPerMechanicalHorsepowerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
index b70ed1583e..ca11428455 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCapacitanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToCapacitance
     /// </summary>
     public static class NumberToCapacitanceExtensions
     {
-        /// <inheritdoc cref="Capacitance.FromFarads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Capacitance.FromFarads(double)" />
         public static Capacitance Farads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Capacitance Farads<T>(this T value)
 #endif
             => Capacitance.FromFarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromKilofarads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Capacitance.FromKilofarads(double)" />
         public static Capacitance Kilofarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Capacitance Kilofarads<T>(this T value)
 #endif
             => Capacitance.FromKilofarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromMegafarads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Capacitance.FromMegafarads(double)" />
         public static Capacitance Megafarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Capacitance Megafarads<T>(this T value)
 #endif
             => Capacitance.FromMegafarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromMicrofarads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Capacitance.FromMicrofarads(double)" />
         public static Capacitance Microfarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Capacitance Microfarads<T>(this T value)
 #endif
             => Capacitance.FromMicrofarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromMillifarads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Capacitance.FromMillifarads(double)" />
         public static Capacitance Millifarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Capacitance Millifarads<T>(this T value)
 #endif
             => Capacitance.FromMillifarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromNanofarads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Capacitance.FromNanofarads(double)" />
         public static Capacitance Nanofarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Capacitance Nanofarads<T>(this T value)
 #endif
             => Capacitance.FromNanofarads(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Capacitance.FromPicofarads(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Capacitance.FromPicofarads(double)" />
         public static Capacitance Picofarads<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
index 7ab80eda79..ad0f6b2bc5 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCoefficientOfThermalExpansionExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToCoefficientOfThermalExpansion
     /// </summary>
     public static class NumberToCoefficientOfThermalExpansionExtensions
     {
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeCelsius(double)" />
         [Obsolete("Use PerDegreeCelsius instead.")]
         public static CoefficientOfThermalExpansion InverseDegreeCelsius<T>(this T value)
             where T : notnull
@@ -41,7 +41,7 @@ public static CoefficientOfThermalExpansion InverseDegreeCelsius<T>(this T value
 #endif
             => CoefficientOfThermalExpansion.FromInverseDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(double)" />
         [Obsolete("Use PerDegreeFahrenheit instead.")]
         public static CoefficientOfThermalExpansion InverseDegreeFahrenheit<T>(this T value)
             where T : notnull
@@ -50,7 +50,7 @@ public static CoefficientOfThermalExpansion InverseDegreeFahrenheit<T>(this T va
 #endif
             => CoefficientOfThermalExpansion.FromInverseDegreeFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromInverseKelvin(double)" />
         [Obsolete("Use PerKelvin instead.")]
         public static CoefficientOfThermalExpansion InverseKelvin<T>(this T value)
             where T : notnull
@@ -59,7 +59,7 @@ public static CoefficientOfThermalExpansion InverseKelvin<T>(this T value)
 #endif
             => CoefficientOfThermalExpansion.FromInverseKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeCelsius(double)" />
         public static CoefficientOfThermalExpansion PerDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -67,7 +67,7 @@ public static CoefficientOfThermalExpansion PerDegreeCelsius<T>(this T value)
 #endif
             => CoefficientOfThermalExpansion.FromPerDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(double)" />
         public static CoefficientOfThermalExpansion PerDegreeFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -75,7 +75,7 @@ public static CoefficientOfThermalExpansion PerDegreeFahrenheit<T>(this T value)
 #endif
             => CoefficientOfThermalExpansion.FromPerDegreeFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPerKelvin(double)" />
         public static CoefficientOfThermalExpansion PerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -83,7 +83,7 @@ public static CoefficientOfThermalExpansion PerKelvin<T>(this T value)
 #endif
             => CoefficientOfThermalExpansion.FromPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(double)" />
         public static CoefficientOfThermalExpansion PpmPerDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -91,7 +91,7 @@ public static CoefficientOfThermalExpansion PpmPerDegreeCelsius<T>(this T value)
 #endif
             => CoefficientOfThermalExpansion.FromPpmPerDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(double)" />
         public static CoefficientOfThermalExpansion PpmPerDegreeFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -99,7 +99,7 @@ public static CoefficientOfThermalExpansion PpmPerDegreeFahrenheit<T>(this T val
 #endif
             => CoefficientOfThermalExpansion.FromPpmPerDegreeFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="CoefficientOfThermalExpansion.FromPpmPerKelvin(double)" />
         public static CoefficientOfThermalExpansion PpmPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs
index bb3cdbbeb0..f5683c23f3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToCompressibilityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToCompressibility
     /// </summary>
     public static class NumberToCompressibilityExtensions
     {
-        /// <inheritdoc cref="Compressibility.FromInverseAtmospheres(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Compressibility.FromInverseAtmospheres(double)" />
         public static Compressibility InverseAtmospheres<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Compressibility InverseAtmospheres<T>(this T value)
 #endif
             => Compressibility.FromInverseAtmospheres(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Compressibility.FromInverseBars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Compressibility.FromInverseBars(double)" />
         public static Compressibility InverseBars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Compressibility InverseBars<T>(this T value)
 #endif
             => Compressibility.FromInverseBars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Compressibility.FromInverseKilopascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Compressibility.FromInverseKilopascals(double)" />
         public static Compressibility InverseKilopascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Compressibility InverseKilopascals<T>(this T value)
 #endif
             => Compressibility.FromInverseKilopascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Compressibility.FromInverseMegapascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Compressibility.FromInverseMegapascals(double)" />
         public static Compressibility InverseMegapascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Compressibility InverseMegapascals<T>(this T value)
 #endif
             => Compressibility.FromInverseMegapascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Compressibility.FromInverseMillibars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Compressibility.FromInverseMillibars(double)" />
         public static Compressibility InverseMillibars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Compressibility InverseMillibars<T>(this T value)
 #endif
             => Compressibility.FromInverseMillibars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Compressibility.FromInversePascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Compressibility.FromInversePascals(double)" />
         public static Compressibility InversePascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Compressibility InversePascals<T>(this T value)
 #endif
             => Compressibility.FromInversePascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Compressibility.FromInversePoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Compressibility.FromInversePoundsForcePerSquareInch(double)" />
         public static Compressibility InversePoundsForcePerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
index fab19c64b9..a10af41796 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToDensity
     /// </summary>
     public static class NumberToDensityExtensions
     {
-        /// <inheritdoc cref="Density.FromCentigramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromCentigramsPerDeciliter(double)" />
         public static Density CentigramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Density CentigramsPerDeciliter<T>(this T value)
 #endif
             => Density.FromCentigramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromCentigramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromCentigramsPerLiter(double)" />
         public static Density CentigramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Density CentigramsPerLiter<T>(this T value)
 #endif
             => Density.FromCentigramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromCentigramsPerMilliliter(double)" />
         public static Density CentigramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Density CentigramsPerMilliliter<T>(this T value)
 #endif
             => Density.FromCentigramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromDecigramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromDecigramsPerDeciliter(double)" />
         public static Density DecigramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Density DecigramsPerDeciliter<T>(this T value)
 #endif
             => Density.FromDecigramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromDecigramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromDecigramsPerLiter(double)" />
         public static Density DecigramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Density DecigramsPerLiter<T>(this T value)
 #endif
             => Density.FromDecigramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromDecigramsPerMilliliter(double)" />
         public static Density DecigramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Density DecigramsPerMilliliter<T>(this T value)
 #endif
             => Density.FromDecigramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromFemtogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromFemtogramsPerDeciliter(double)" />
         public static Density FemtogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Density FemtogramsPerDeciliter<T>(this T value)
 #endif
             => Density.FromFemtogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromFemtogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromFemtogramsPerLiter(double)" />
         public static Density FemtogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Density FemtogramsPerLiter<T>(this T value)
 #endif
             => Density.FromFemtogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromFemtogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromFemtogramsPerMilliliter(double)" />
         public static Density FemtogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Density FemtogramsPerMilliliter<T>(this T value)
 #endif
             => Density.FromFemtogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicCentimeter(double)" />
         public static Density GramsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Density GramsPerCubicCentimeter<T>(this T value)
 #endif
             => Density.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicFoot(double)" />
         public static Density GramsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Density GramsPerCubicFoot<T>(this T value)
 #endif
             => Density.FromGramsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicInch(double)" />
         public static Density GramsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Density GramsPerCubicInch<T>(this T value)
 #endif
             => Density.FromGramsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicMeter(double)" />
         public static Density GramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Density GramsPerCubicMeter<T>(this T value)
 #endif
             => Density.FromGramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromGramsPerCubicMillimeter(double)" />
         public static Density GramsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Density GramsPerCubicMillimeter<T>(this T value)
 #endif
             => Density.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromGramsPerDeciliter(double)" />
         public static Density GramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Density GramsPerDeciliter<T>(this T value)
 #endif
             => Density.FromGramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromGramsPerLiter(double)" />
         public static Density GramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Density GramsPerLiter<T>(this T value)
 #endif
             => Density.FromGramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromGramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromGramsPerMilliliter(double)" />
         public static Density GramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Density GramsPerMilliliter<T>(this T value)
 #endif
             => Density.FromGramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicCentimeter(double)" />
         public static Density KilogramsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Density KilogramsPerCubicCentimeter<T>(this T value)
 #endif
             => Density.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicMeter(double)" />
         public static Density KilogramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Density KilogramsPerCubicMeter<T>(this T value)
 #endif
             => Density.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromKilogramsPerCubicMillimeter(double)" />
         public static Density KilogramsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Density KilogramsPerCubicMillimeter<T>(this T value)
 #endif
             => Density.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromKilogramsPerLiter(double)" />
         public static Density KilogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Density KilogramsPerLiter<T>(this T value)
 #endif
             => Density.FromKilogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromKilopoundsPerCubicFoot(double)" />
         public static Density KilopoundsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Density KilopoundsPerCubicFoot<T>(this T value)
 #endif
             => Density.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromKilopoundsPerCubicInch(double)" />
         public static Density KilopoundsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Density KilopoundsPerCubicInch<T>(this T value)
 #endif
             => Density.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromKilopoundsPerCubicYard(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromKilopoundsPerCubicYard(double)" />
         public static Density KilopoundsPerCubicYard<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Density KilopoundsPerCubicYard<T>(this T value)
 #endif
             => Density.FromKilopoundsPerCubicYard(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromMicrogramsPerCubicMeter(double)" />
         public static Density MicrogramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Density MicrogramsPerCubicMeter<T>(this T value)
 #endif
             => Density.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromMicrogramsPerDeciliter(double)" />
         public static Density MicrogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static Density MicrogramsPerDeciliter<T>(this T value)
 #endif
             => Density.FromMicrogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromMicrogramsPerLiter(double)" />
         public static Density MicrogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static Density MicrogramsPerLiter<T>(this T value)
 #endif
             => Density.FromMicrogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromMicrogramsPerMilliliter(double)" />
         public static Density MicrogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static Density MicrogramsPerMilliliter<T>(this T value)
 #endif
             => Density.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromMilligramsPerCubicMeter(double)" />
         public static Density MilligramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static Density MilligramsPerCubicMeter<T>(this T value)
 #endif
             => Density.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMilligramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromMilligramsPerDeciliter(double)" />
         public static Density MilligramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static Density MilligramsPerDeciliter<T>(this T value)
 #endif
             => Density.FromMilligramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMilligramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromMilligramsPerLiter(double)" />
         public static Density MilligramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static Density MilligramsPerLiter<T>(this T value)
 #endif
             => Density.FromMilligramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromMilligramsPerMilliliter(double)" />
         public static Density MilligramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static Density MilligramsPerMilliliter<T>(this T value)
 #endif
             => Density.FromMilligramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromNanogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromNanogramsPerDeciliter(double)" />
         public static Density NanogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static Density NanogramsPerDeciliter<T>(this T value)
 #endif
             => Density.FromNanogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromNanogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromNanogramsPerLiter(double)" />
         public static Density NanogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static Density NanogramsPerLiter<T>(this T value)
 #endif
             => Density.FromNanogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromNanogramsPerMilliliter(double)" />
         public static Density NanogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static Density NanogramsPerMilliliter<T>(this T value)
 #endif
             => Density.FromNanogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPicogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPicogramsPerDeciliter(double)" />
         public static Density PicogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static Density PicogramsPerDeciliter<T>(this T value)
 #endif
             => Density.FromPicogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPicogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPicogramsPerLiter(double)" />
         public static Density PicogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static Density PicogramsPerLiter<T>(this T value)
 #endif
             => Density.FromPicogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPicogramsPerMilliliter(double)" />
         public static Density PicogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -336,7 +336,7 @@ public static Density PicogramsPerMilliliter<T>(this T value)
 #endif
             => Density.FromPicogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicCentimeter(double)" />
         public static Density PoundsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -344,7 +344,7 @@ public static Density PoundsPerCubicCentimeter<T>(this T value)
 #endif
             => Density.FromPoundsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicFoot(double)" />
         public static Density PoundsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -352,7 +352,7 @@ public static Density PoundsPerCubicFoot<T>(this T value)
 #endif
             => Density.FromPoundsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicInch(double)" />
         public static Density PoundsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -360,7 +360,7 @@ public static Density PoundsPerCubicInch<T>(this T value)
 #endif
             => Density.FromPoundsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicMeter(double)" />
         public static Density PoundsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -368,7 +368,7 @@ public static Density PoundsPerCubicMeter<T>(this T value)
 #endif
             => Density.FromPoundsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicMillimeter(double)" />
         public static Density PoundsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -376,7 +376,7 @@ public static Density PoundsPerCubicMillimeter<T>(this T value)
 #endif
             => Density.FromPoundsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerCubicYard(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPoundsPerCubicYard(double)" />
         public static Density PoundsPerCubicYard<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -384,7 +384,7 @@ public static Density PoundsPerCubicYard<T>(this T value)
 #endif
             => Density.FromPoundsPerCubicYard(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPoundsPerImperialGallon(double)" />
         public static Density PoundsPerImperialGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -392,7 +392,7 @@ public static Density PoundsPerImperialGallon<T>(this T value)
 #endif
             => Density.FromPoundsPerImperialGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromPoundsPerUSGallon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromPoundsPerUSGallon(double)" />
         public static Density PoundsPerUSGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -400,7 +400,7 @@ public static Density PoundsPerUSGallon<T>(this T value)
 #endif
             => Density.FromPoundsPerUSGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicCentimeter(double)" />
         public static Density SlugsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -408,7 +408,7 @@ public static Density SlugsPerCubicCentimeter<T>(this T value)
 #endif
             => Density.FromSlugsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicFoot(double)" />
         public static Density SlugsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -416,7 +416,7 @@ public static Density SlugsPerCubicFoot<T>(this T value)
 #endif
             => Density.FromSlugsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicInch(double)" />
         public static Density SlugsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -424,7 +424,7 @@ public static Density SlugsPerCubicInch<T>(this T value)
 #endif
             => Density.FromSlugsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicMeter(double)" />
         public static Density SlugsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -432,7 +432,7 @@ public static Density SlugsPerCubicMeter<T>(this T value)
 #endif
             => Density.FromSlugsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromSlugsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromSlugsPerCubicMillimeter(double)" />
         public static Density SlugsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -440,7 +440,7 @@ public static Density SlugsPerCubicMillimeter<T>(this T value)
 #endif
             => Density.FromSlugsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicCentimeter(double)" />
         public static Density TonnesPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -448,7 +448,7 @@ public static Density TonnesPerCubicCentimeter<T>(this T value)
 #endif
             => Density.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicFoot(double)" />
         public static Density TonnesPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -456,7 +456,7 @@ public static Density TonnesPerCubicFoot<T>(this T value)
 #endif
             => Density.FromTonnesPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicInch(double)" />
         public static Density TonnesPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -464,7 +464,7 @@ public static Density TonnesPerCubicInch<T>(this T value)
 #endif
             => Density.FromTonnesPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicMeter(double)" />
         public static Density TonnesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -472,7 +472,7 @@ public static Density TonnesPerCubicMeter<T>(this T value)
 #endif
             => Density.FromTonnesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Density.FromTonnesPerCubicMillimeter(double)" />
         public static Density TonnesPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
index 70318cf6a5..518f224453 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDurationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToDuration
     /// </summary>
     public static class NumberToDurationExtensions
     {
-        /// <inheritdoc cref="Duration.FromDays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromDays(double)" />
         public static Duration Days<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Duration Days<T>(this T value)
 #endif
             => Duration.FromDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromHours(double)" />
         public static Duration Hours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Duration Hours<T>(this T value)
 #endif
             => Duration.FromHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromJulianYears(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromJulianYears(double)" />
         public static Duration JulianYears<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Duration JulianYears<T>(this T value)
 #endif
             => Duration.FromJulianYears(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromMicroseconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromMicroseconds(double)" />
         public static Duration Microseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Duration Microseconds<T>(this T value)
 #endif
             => Duration.FromMicroseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromMilliseconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromMilliseconds(double)" />
         public static Duration Milliseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Duration Milliseconds<T>(this T value)
 #endif
             => Duration.FromMilliseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromMinutes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromMinutes(double)" />
         public static Duration Minutes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Duration Minutes<T>(this T value)
 #endif
             => Duration.FromMinutes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromMonths30(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromMonths30(double)" />
         public static Duration Months30<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Duration Months30<T>(this T value)
 #endif
             => Duration.FromMonths30(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromNanoseconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromNanoseconds(double)" />
         public static Duration Nanoseconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Duration Nanoseconds<T>(this T value)
 #endif
             => Duration.FromNanoseconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromSeconds(double)" />
         public static Duration Seconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Duration Seconds<T>(this T value)
 #endif
             => Duration.FromSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromWeeks(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromWeeks(double)" />
         public static Duration Weeks<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Duration Weeks<T>(this T value)
 #endif
             => Duration.FromWeeks(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Duration.FromYears365(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Duration.FromYears365(double)" />
         public static Duration Years365<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
index 5d955b9d26..59c792b747 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToDynamicViscosityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToDynamicViscosity
     /// </summary>
     public static class NumberToDynamicViscosityExtensions
     {
-        /// <inheritdoc cref="DynamicViscosity.FromCentipoise(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromCentipoise(double)" />
         public static DynamicViscosity Centipoise<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static DynamicViscosity Centipoise<T>(this T value)
 #endif
             => DynamicViscosity.FromCentipoise(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromMicropascalSeconds(double)" />
         public static DynamicViscosity MicropascalSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static DynamicViscosity MicropascalSeconds<T>(this T value)
 #endif
             => DynamicViscosity.FromMicropascalSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromMillipascalSeconds(double)" />
         public static DynamicViscosity MillipascalSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static DynamicViscosity MillipascalSeconds<T>(this T value)
 #endif
             => DynamicViscosity.FromMillipascalSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromNewtonSecondsPerMeterSquared(double)" />
         public static DynamicViscosity NewtonSecondsPerMeterSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static DynamicViscosity NewtonSecondsPerMeterSquared<T>(this T value)
 #endif
             => DynamicViscosity.FromNewtonSecondsPerMeterSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPascalSeconds(double)" />
         public static DynamicViscosity PascalSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static DynamicViscosity PascalSeconds<T>(this T value)
 #endif
             => DynamicViscosity.FromPascalSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoise(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPoise(double)" />
         public static DynamicViscosity Poise<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static DynamicViscosity Poise<T>(this T value)
 #endif
             => DynamicViscosity.FromPoise(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareFoot(double)" />
         public static DynamicViscosity PoundsForceSecondPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static DynamicViscosity PoundsForceSecondPerSquareFoot<T>(this T value)
 #endif
             => DynamicViscosity.FromPoundsForceSecondPerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPoundsForceSecondPerSquareInch(double)" />
         public static DynamicViscosity PoundsForceSecondPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static DynamicViscosity PoundsForceSecondPerSquareInch<T>(this T value)
 #endif
             => DynamicViscosity.FromPoundsForceSecondPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromPoundsPerFootSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromPoundsPerFootSecond(double)" />
         public static DynamicViscosity PoundsPerFootSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static DynamicViscosity PoundsPerFootSecond<T>(this T value)
 #endif
             => DynamicViscosity.FromPoundsPerFootSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="DynamicViscosity.FromReyns(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="DynamicViscosity.FromReyns(double)" />
         public static DynamicViscosity Reyns<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
index 8d84623f00..b02da0f9f6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricAdmittanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricAdmittance
     /// </summary>
     public static class NumberToElectricAdmittanceExtensions
     {
-        /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMicrosiemens(double)" />
         public static ElectricAdmittance Microsiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricAdmittance Microsiemens<T>(this T value)
 #endif
             => ElectricAdmittance.FromMicrosiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromMillisiemens(double)" />
         public static ElectricAdmittance Millisiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricAdmittance Millisiemens<T>(this T value)
 #endif
             => ElectricAdmittance.FromMillisiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromNanosiemens(double)" />
         public static ElectricAdmittance Nanosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricAdmittance Nanosiemens<T>(this T value)
 #endif
             => ElectricAdmittance.FromNanosiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricAdmittance.FromSiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricAdmittance.FromSiemens(double)" />
         public static ElectricAdmittance Siemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
index 1e7609d96a..640d805651 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricChargeDensity
     /// </summary>
     public static class NumberToElectricChargeDensityExtensions
     {
-        /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricChargeDensity.FromCoulombsPerCubicMeter(double)" />
         public static ElectricChargeDensity CoulombsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
index e4e4376f61..422aa5f121 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricChargeExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCharge
     /// </summary>
     public static class NumberToElectricChargeExtensions
     {
-        /// <inheritdoc cref="ElectricCharge.FromAmpereHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromAmpereHours(double)" />
         public static ElectricCharge AmpereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricCharge AmpereHours<T>(this T value)
 #endif
             => ElectricCharge.FromAmpereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromCoulombs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromCoulombs(double)" />
         public static ElectricCharge Coulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricCharge Coulombs<T>(this T value)
 #endif
             => ElectricCharge.FromCoulombs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromKiloampereHours(double)" />
         public static ElectricCharge KiloampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricCharge KiloampereHours<T>(this T value)
 #endif
             => ElectricCharge.FromKiloampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromKilocoulombs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromKilocoulombs(double)" />
         public static ElectricCharge Kilocoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricCharge Kilocoulombs<T>(this T value)
 #endif
             => ElectricCharge.FromKilocoulombs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromMegaampereHours(double)" />
         public static ElectricCharge MegaampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ElectricCharge MegaampereHours<T>(this T value)
 #endif
             => ElectricCharge.FromMegaampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromMegacoulombs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromMegacoulombs(double)" />
         public static ElectricCharge Megacoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ElectricCharge Megacoulombs<T>(this T value)
 #endif
             => ElectricCharge.FromMegacoulombs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromMicrocoulombs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromMicrocoulombs(double)" />
         public static ElectricCharge Microcoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static ElectricCharge Microcoulombs<T>(this T value)
 #endif
             => ElectricCharge.FromMicrocoulombs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromMilliampereHours(double)" />
         public static ElectricCharge MilliampereHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static ElectricCharge MilliampereHours<T>(this T value)
 #endif
             => ElectricCharge.FromMilliampereHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromMillicoulombs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromMillicoulombs(double)" />
         public static ElectricCharge Millicoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static ElectricCharge Millicoulombs<T>(this T value)
 #endif
             => ElectricCharge.FromMillicoulombs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromNanocoulombs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromNanocoulombs(double)" />
         public static ElectricCharge Nanocoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static ElectricCharge Nanocoulombs<T>(this T value)
 #endif
             => ElectricCharge.FromNanocoulombs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCharge.FromPicocoulombs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCharge.FromPicocoulombs(double)" />
         public static ElectricCharge Picocoulombs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
index e7ba0e2806..d656b7462b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricConductance
     /// </summary>
     public static class NumberToElectricConductanceExtensions
     {
-        /// <inheritdoc cref="ElectricConductance.FromKilosiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductance.FromKilosiemens(double)" />
         public static ElectricConductance Kilosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricConductance Kilosiemens<T>(this T value)
 #endif
             => ElectricConductance.FromKilosiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductance.FromMicrosiemens(double)" />
         public static ElectricConductance Microsiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricConductance Microsiemens<T>(this T value)
 #endif
             => ElectricConductance.FromMicrosiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductance.FromMillisiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductance.FromMillisiemens(double)" />
         public static ElectricConductance Millisiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricConductance Millisiemens<T>(this T value)
 #endif
             => ElectricConductance.FromMillisiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductance.FromNanosiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductance.FromNanosiemens(double)" />
         public static ElectricConductance Nanosiemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricConductance Nanosiemens<T>(this T value)
 #endif
             => ElectricConductance.FromNanosiemens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductance.FromSiemens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductance.FromSiemens(double)" />
         public static ElectricConductance Siemens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
index a901af79db..d5a791c5c9 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricConductivityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricConductivity
     /// </summary>
     public static class NumberToElectricConductivityExtensions
     {
-        /// <inheritdoc cref="ElectricConductivity.FromMicrosiemensPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductivity.FromMicrosiemensPerCentimeter(double)" />
         public static ElectricConductivity MicrosiemensPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricConductivity MicrosiemensPerCentimeter<T>(this T value)
 #endif
             => ElectricConductivity.FromMicrosiemensPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductivity.FromMillisiemensPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductivity.FromMillisiemensPerCentimeter(double)" />
         public static ElectricConductivity MillisiemensPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricConductivity MillisiemensPerCentimeter<T>(this T value)
 #endif
             => ElectricConductivity.FromMillisiemensPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerCentimeter(double)" />
         public static ElectricConductivity SiemensPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricConductivity SiemensPerCentimeter<T>(this T value)
 #endif
             => ElectricConductivity.FromSiemensPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerFoot(double)" />
         public static ElectricConductivity SiemensPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricConductivity SiemensPerFoot<T>(this T value)
 #endif
             => ElectricConductivity.FromSiemensPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerInch(double)" />
         public static ElectricConductivity SiemensPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ElectricConductivity SiemensPerInch<T>(this T value)
 #endif
             => ElectricConductivity.FromSiemensPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricConductivity.FromSiemensPerMeter(double)" />
         public static ElectricConductivity SiemensPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
index d77451ffa8..58d52df54b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrentDensity
     /// </summary>
     public static class NumberToElectricCurrentDensityExtensions
     {
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareFoot(double)" />
         public static ElectricCurrentDensity AmperesPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricCurrentDensity AmperesPerSquareFoot<T>(this T value)
 #endif
             => ElectricCurrentDensity.FromAmperesPerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareInch(double)" />
         public static ElectricCurrentDensity AmperesPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricCurrentDensity AmperesPerSquareInch<T>(this T value)
 #endif
             => ElectricCurrentDensity.FromAmperesPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentDensity.FromAmperesPerSquareMeter(double)" />
         public static ElectricCurrentDensity AmperesPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
index e77703c45d..42816bffd1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrent
     /// </summary>
     public static class NumberToElectricCurrentExtensions
     {
-        /// <inheritdoc cref="ElectricCurrent.FromAmperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromAmperes(double)" />
         public static ElectricCurrent Amperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricCurrent Amperes<T>(this T value)
 #endif
             => ElectricCurrent.FromAmperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromCentiamperes(double)" />
         public static ElectricCurrent Centiamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricCurrent Centiamperes<T>(this T value)
 #endif
             => ElectricCurrent.FromCentiamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromFemtoamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromFemtoamperes(double)" />
         public static ElectricCurrent Femtoamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricCurrent Femtoamperes<T>(this T value)
 #endif
             => ElectricCurrent.FromFemtoamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromKiloamperes(double)" />
         public static ElectricCurrent Kiloamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricCurrent Kiloamperes<T>(this T value)
 #endif
             => ElectricCurrent.FromKiloamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromMegaamperes(double)" />
         public static ElectricCurrent Megaamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ElectricCurrent Megaamperes<T>(this T value)
 #endif
             => ElectricCurrent.FromMegaamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromMicroamperes(double)" />
         public static ElectricCurrent Microamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ElectricCurrent Microamperes<T>(this T value)
 #endif
             => ElectricCurrent.FromMicroamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromMilliamperes(double)" />
         public static ElectricCurrent Milliamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static ElectricCurrent Milliamperes<T>(this T value)
 #endif
             => ElectricCurrent.FromMilliamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromNanoamperes(double)" />
         public static ElectricCurrent Nanoamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static ElectricCurrent Nanoamperes<T>(this T value)
 #endif
             => ElectricCurrent.FromNanoamperes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrent.FromPicoamperes(double)" />
         public static ElectricCurrent Picoamperes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
index 2aa7b4d12b..898b7c41e0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricCurrentGradientExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricCurrentGradient
     /// </summary>
     public static class NumberToElectricCurrentGradientExtensions
     {
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMicrosecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMicrosecond(double)" />
         public static ElectricCurrentGradient AmperesPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricCurrentGradient AmperesPerMicrosecond<T>(this T value)
 #endif
             => ElectricCurrentGradient.FromAmperesPerMicrosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMillisecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMillisecond(double)" />
         public static ElectricCurrentGradient AmperesPerMillisecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricCurrentGradient AmperesPerMillisecond<T>(this T value)
 #endif
             => ElectricCurrentGradient.FromAmperesPerMillisecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerMinute(double)" />
         public static ElectricCurrentGradient AmperesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricCurrentGradient AmperesPerMinute<T>(this T value)
 #endif
             => ElectricCurrentGradient.FromAmperesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerNanosecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerNanosecond(double)" />
         public static ElectricCurrentGradient AmperesPerNanosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricCurrentGradient AmperesPerNanosecond<T>(this T value)
 #endif
             => ElectricCurrentGradient.FromAmperesPerNanosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromAmperesPerSecond(double)" />
         public static ElectricCurrentGradient AmperesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ElectricCurrentGradient AmperesPerSecond<T>(this T value)
 #endif
             => ElectricCurrentGradient.FromAmperesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerMinute(double)" />
         public static ElectricCurrentGradient MilliamperesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ElectricCurrentGradient MilliamperesPerMinute<T>(this T value)
 #endif
             => ElectricCurrentGradient.FromMilliamperesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricCurrentGradient.FromMilliamperesPerSecond(double)" />
         public static ElectricCurrentGradient MilliamperesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
index 72d4932716..bb9a391be8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricFieldExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricField
     /// </summary>
     public static class NumberToElectricFieldExtensions
     {
-        /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricField.FromVoltsPerMeter(double)" />
         public static ElectricField VoltsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
index 40356c4efc..07aedbcbb2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricInductanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricInductance
     /// </summary>
     public static class NumberToElectricInductanceExtensions
     {
-        /// <inheritdoc cref="ElectricInductance.FromHenries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricInductance.FromHenries(double)" />
         public static ElectricInductance Henries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricInductance Henries<T>(this T value)
 #endif
             => ElectricInductance.FromHenries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricInductance.FromMicrohenries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricInductance.FromMicrohenries(double)" />
         public static ElectricInductance Microhenries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricInductance Microhenries<T>(this T value)
 #endif
             => ElectricInductance.FromMicrohenries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricInductance.FromMillihenries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricInductance.FromMillihenries(double)" />
         public static ElectricInductance Millihenries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricInductance Millihenries<T>(this T value)
 #endif
             => ElectricInductance.FromMillihenries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricInductance.FromNanohenries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricInductance.FromNanohenries(double)" />
         public static ElectricInductance Nanohenries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricInductance Nanohenries<T>(this T value)
 #endif
             => ElectricInductance.FromNanohenries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricInductance.FromPicohenries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricInductance.FromPicohenries(double)" />
         public static ElectricInductance Picohenries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
index 24cb4db585..cb96006b46 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialAcExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotentialAc
     /// </summary>
     public static class NumberToElectricPotentialAcExtensions
     {
-        /// <inheritdoc cref="ElectricPotentialAc.FromKilovoltsAc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialAc.FromKilovoltsAc(double)" />
         public static ElectricPotentialAc KilovoltsAc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricPotentialAc KilovoltsAc<T>(this T value)
 #endif
             => ElectricPotentialAc.FromKilovoltsAc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialAc.FromMegavoltsAc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialAc.FromMegavoltsAc(double)" />
         public static ElectricPotentialAc MegavoltsAc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricPotentialAc MegavoltsAc<T>(this T value)
 #endif
             => ElectricPotentialAc.FromMegavoltsAc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialAc.FromMicrovoltsAc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialAc.FromMicrovoltsAc(double)" />
         public static ElectricPotentialAc MicrovoltsAc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricPotentialAc MicrovoltsAc<T>(this T value)
 #endif
             => ElectricPotentialAc.FromMicrovoltsAc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialAc.FromMillivoltsAc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialAc.FromMillivoltsAc(double)" />
         public static ElectricPotentialAc MillivoltsAc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricPotentialAc MillivoltsAc<T>(this T value)
 #endif
             => ElectricPotentialAc.FromMillivoltsAc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialAc.FromVoltsAc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialAc.FromVoltsAc(double)" />
         public static ElectricPotentialAc VoltsAc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
index c41cfd13ba..3381b64770 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialChangeRateExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotentialChangeRate
     /// </summary>
     public static class NumberToElectricPotentialChangeRateExtensions
     {
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerHour(double)" />
         public static ElectricPotentialChangeRate KilovoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricPotentialChangeRate KilovoltsPerHour<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromKilovoltsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(double)" />
         public static ElectricPotentialChangeRate KilovoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricPotentialChangeRate KilovoltsPerMicrosecond<T>(this T valu
 #endif
             => ElectricPotentialChangeRate.FromKilovoltsPerMicrosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerMinute(double)" />
         public static ElectricPotentialChangeRate KilovoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricPotentialChangeRate KilovoltsPerMinute<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromKilovoltsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromKilovoltsPerSecond(double)" />
         public static ElectricPotentialChangeRate KilovoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricPotentialChangeRate KilovoltsPerSecond<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromKilovoltsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerHour(double)" />
         public static ElectricPotentialChangeRate MegavoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ElectricPotentialChangeRate MegavoltsPerHour<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMegavoltsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(double)" />
         public static ElectricPotentialChangeRate MegavoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ElectricPotentialChangeRate MegavoltsPerMicrosecond<T>(this T valu
 #endif
             => ElectricPotentialChangeRate.FromMegavoltsPerMicrosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerMinute(double)" />
         public static ElectricPotentialChangeRate MegavoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static ElectricPotentialChangeRate MegavoltsPerMinute<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMegavoltsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMegavoltsPerSecond(double)" />
         public static ElectricPotentialChangeRate MegavoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static ElectricPotentialChangeRate MegavoltsPerSecond<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMegavoltsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerHour(double)" />
         public static ElectricPotentialChangeRate MicrovoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static ElectricPotentialChangeRate MicrovoltsPerHour<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMicrovoltsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(double)" />
         public static ElectricPotentialChangeRate MicrovoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static ElectricPotentialChangeRate MicrovoltsPerMicrosecond<T>(this T val
 #endif
             => ElectricPotentialChangeRate.FromMicrovoltsPerMicrosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerMinute(double)" />
         public static ElectricPotentialChangeRate MicrovoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static ElectricPotentialChangeRate MicrovoltsPerMinute<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMicrovoltsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMicrovoltsPerSecond(double)" />
         public static ElectricPotentialChangeRate MicrovoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static ElectricPotentialChangeRate MicrovoltsPerSecond<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMicrovoltsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerHour(double)" />
         public static ElectricPotentialChangeRate MillivoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static ElectricPotentialChangeRate MillivoltsPerHour<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMillivoltsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(double)" />
         public static ElectricPotentialChangeRate MillivoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static ElectricPotentialChangeRate MillivoltsPerMicrosecond<T>(this T val
 #endif
             => ElectricPotentialChangeRate.FromMillivoltsPerMicrosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerMinute(double)" />
         public static ElectricPotentialChangeRate MillivoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static ElectricPotentialChangeRate MillivoltsPerMinute<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMillivoltsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromMillivoltsPerSecond(double)" />
         public static ElectricPotentialChangeRate MillivoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static ElectricPotentialChangeRate MillivoltsPerSecond<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromMillivoltsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerHour(double)" />
         public static ElectricPotentialChangeRate VoltsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static ElectricPotentialChangeRate VoltsPerHour<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromVoltsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMicrosecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMicrosecond(double)" />
         public static ElectricPotentialChangeRate VoltsPerMicrosecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static ElectricPotentialChangeRate VoltsPerMicrosecond<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromVoltsPerMicrosecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerMinute(double)" />
         public static ElectricPotentialChangeRate VoltsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static ElectricPotentialChangeRate VoltsPerMinute<T>(this T value)
 #endif
             => ElectricPotentialChangeRate.FromVoltsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialChangeRate.FromVoltsPerSecond(double)" />
         public static ElectricPotentialChangeRate VoltsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
index 62ab533375..a8614fd5db 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialDcExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotentialDc
     /// </summary>
     public static class NumberToElectricPotentialDcExtensions
     {
-        /// <inheritdoc cref="ElectricPotentialDc.FromKilovoltsDc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialDc.FromKilovoltsDc(double)" />
         public static ElectricPotentialDc KilovoltsDc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricPotentialDc KilovoltsDc<T>(this T value)
 #endif
             => ElectricPotentialDc.FromKilovoltsDc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialDc.FromMegavoltsDc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialDc.FromMegavoltsDc(double)" />
         public static ElectricPotentialDc MegavoltsDc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricPotentialDc MegavoltsDc<T>(this T value)
 #endif
             => ElectricPotentialDc.FromMegavoltsDc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialDc.FromMicrovoltsDc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialDc.FromMicrovoltsDc(double)" />
         public static ElectricPotentialDc MicrovoltsDc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricPotentialDc MicrovoltsDc<T>(this T value)
 #endif
             => ElectricPotentialDc.FromMicrovoltsDc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialDc.FromMillivoltsDc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialDc.FromMillivoltsDc(double)" />
         public static ElectricPotentialDc MillivoltsDc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricPotentialDc MillivoltsDc<T>(this T value)
 #endif
             => ElectricPotentialDc.FromMillivoltsDc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotentialDc.FromVoltsDc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotentialDc.FromVoltsDc(double)" />
         public static ElectricPotentialDc VoltsDc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
index 0c3a18b571..c89a5069a6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricPotentialExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricPotential
     /// </summary>
     public static class NumberToElectricPotentialExtensions
     {
-        /// <inheritdoc cref="ElectricPotential.FromKilovolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotential.FromKilovolts(double)" />
         public static ElectricPotential Kilovolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricPotential Kilovolts<T>(this T value)
 #endif
             => ElectricPotential.FromKilovolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromMegavolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotential.FromMegavolts(double)" />
         public static ElectricPotential Megavolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricPotential Megavolts<T>(this T value)
 #endif
             => ElectricPotential.FromMegavolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromMicrovolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotential.FromMicrovolts(double)" />
         public static ElectricPotential Microvolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricPotential Microvolts<T>(this T value)
 #endif
             => ElectricPotential.FromMicrovolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromMillivolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotential.FromMillivolts(double)" />
         public static ElectricPotential Millivolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricPotential Millivolts<T>(this T value)
 #endif
             => ElectricPotential.FromMillivolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromNanovolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotential.FromNanovolts(double)" />
         public static ElectricPotential Nanovolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ElectricPotential Nanovolts<T>(this T value)
 #endif
             => ElectricPotential.FromNanovolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricPotential.FromVolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricPotential.FromVolts(double)" />
         public static ElectricPotential Volts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
index a616e57ac7..99e17110cf 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricResistance
     /// </summary>
     public static class NumberToElectricResistanceExtensions
     {
-        /// <inheritdoc cref="ElectricResistance.FromGigaohms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistance.FromGigaohms(double)" />
         public static ElectricResistance Gigaohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricResistance Gigaohms<T>(this T value)
 #endif
             => ElectricResistance.FromGigaohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromKiloohms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistance.FromKiloohms(double)" />
         public static ElectricResistance Kiloohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricResistance Kiloohms<T>(this T value)
 #endif
             => ElectricResistance.FromKiloohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromMegaohms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistance.FromMegaohms(double)" />
         public static ElectricResistance Megaohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricResistance Megaohms<T>(this T value)
 #endif
             => ElectricResistance.FromMegaohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromMicroohms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistance.FromMicroohms(double)" />
         public static ElectricResistance Microohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricResistance Microohms<T>(this T value)
 #endif
             => ElectricResistance.FromMicroohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromMilliohms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistance.FromMilliohms(double)" />
         public static ElectricResistance Milliohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ElectricResistance Milliohms<T>(this T value)
 #endif
             => ElectricResistance.FromMilliohms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromOhms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistance.FromOhms(double)" />
         public static ElectricResistance Ohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ElectricResistance Ohms<T>(this T value)
 #endif
             => ElectricResistance.FromOhms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistance.FromTeraohms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistance.FromTeraohms(double)" />
         public static ElectricResistance Teraohms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
index 78ab4c55fa..4beb953b18 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricResistivityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricResistivity
     /// </summary>
     public static class NumberToElectricResistivityExtensions
     {
-        /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromKiloohmsCentimeter(double)" />
         public static ElectricResistivity KiloohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricResistivity KiloohmsCentimeter<T>(this T value)
 #endif
             => ElectricResistivity.FromKiloohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromKiloohmMeters(double)" />
         public static ElectricResistivity KiloohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricResistivity KiloohmMeters<T>(this T value)
 #endif
             => ElectricResistivity.FromKiloohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMegaohmsCentimeter(double)" />
         public static ElectricResistivity MegaohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ElectricResistivity MegaohmsCentimeter<T>(this T value)
 #endif
             => ElectricResistivity.FromMegaohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMegaohmMeters(double)" />
         public static ElectricResistivity MegaohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ElectricResistivity MegaohmMeters<T>(this T value)
 #endif
             => ElectricResistivity.FromMegaohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMicroohmsCentimeter(double)" />
         public static ElectricResistivity MicroohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ElectricResistivity MicroohmsCentimeter<T>(this T value)
 #endif
             => ElectricResistivity.FromMicroohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMicroohmMeters(double)" />
         public static ElectricResistivity MicroohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ElectricResistivity MicroohmMeters<T>(this T value)
 #endif
             => ElectricResistivity.FromMicroohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMilliohmsCentimeter(double)" />
         public static ElectricResistivity MilliohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static ElectricResistivity MilliohmsCentimeter<T>(this T value)
 #endif
             => ElectricResistivity.FromMilliohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromMilliohmMeters(double)" />
         public static ElectricResistivity MilliohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static ElectricResistivity MilliohmMeters<T>(this T value)
 #endif
             => ElectricResistivity.FromMilliohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromNanoohmsCentimeter(double)" />
         public static ElectricResistivity NanoohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static ElectricResistivity NanoohmsCentimeter<T>(this T value)
 #endif
             => ElectricResistivity.FromNanoohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromNanoohmMeters(double)" />
         public static ElectricResistivity NanoohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static ElectricResistivity NanoohmMeters<T>(this T value)
 #endif
             => ElectricResistivity.FromNanoohmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromOhmsCentimeter(double)" />
         public static ElectricResistivity OhmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static ElectricResistivity OhmsCentimeter<T>(this T value)
 #endif
             => ElectricResistivity.FromOhmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromOhmMeters(double)" />
         public static ElectricResistivity OhmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static ElectricResistivity OhmMeters<T>(this T value)
 #endif
             => ElectricResistivity.FromOhmMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromPicoohmsCentimeter(double)" />
         public static ElectricResistivity PicoohmsCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static ElectricResistivity PicoohmsCentimeter<T>(this T value)
 #endif
             => ElectricResistivity.FromPicoohmsCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricResistivity.FromPicoohmMeters(double)" />
         public static ElectricResistivity PicoohmMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
index efb17fb6de..4324398c42 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToElectricSurfaceChargeDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToElectricSurfaceChargeDensity
     /// </summary>
     public static class NumberToElectricSurfaceChargeDensityExtensions
     {
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(double)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ElectricSurfaceChargeDensity CoulombsPerSquareCentimeter<T>(this T
 #endif
             => ElectricSurfaceChargeDensity.FromCoulombsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(double)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ElectricSurfaceChargeDensity CoulombsPerSquareInch<T>(this T value
 #endif
             => ElectricSurfaceChargeDensity.FromCoulombsPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ElectricSurfaceChargeDensity.FromCoulombsPerSquareMeter(double)" />
         public static ElectricSurfaceChargeDensity CoulombsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
index 0533f56582..6cc51eeee6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToEnergyDensity
     /// </summary>
     public static class NumberToEnergyDensityExtensions
     {
-        /// <inheritdoc cref="EnergyDensity.FromGigajoulesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromGigajoulesPerCubicMeter(double)" />
         public static EnergyDensity GigajoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static EnergyDensity GigajoulesPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromGigajoulesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromGigawattHoursPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromGigawattHoursPerCubicMeter(double)" />
         public static EnergyDensity GigawattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static EnergyDensity GigawattHoursPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromGigawattHoursPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromJoulesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromJoulesPerCubicMeter(double)" />
         public static EnergyDensity JoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static EnergyDensity JoulesPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromJoulesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromKilojoulesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromKilojoulesPerCubicMeter(double)" />
         public static EnergyDensity KilojoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static EnergyDensity KilojoulesPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromKilojoulesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromKilowattHoursPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromKilowattHoursPerCubicMeter(double)" />
         public static EnergyDensity KilowattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static EnergyDensity KilowattHoursPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromKilowattHoursPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromMegajoulesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromMegajoulesPerCubicMeter(double)" />
         public static EnergyDensity MegajoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static EnergyDensity MegajoulesPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromMegajoulesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromMegawattHoursPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromMegawattHoursPerCubicMeter(double)" />
         public static EnergyDensity MegawattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static EnergyDensity MegawattHoursPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromMegawattHoursPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromPetajoulesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromPetajoulesPerCubicMeter(double)" />
         public static EnergyDensity PetajoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static EnergyDensity PetajoulesPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromPetajoulesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromPetawattHoursPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromPetawattHoursPerCubicMeter(double)" />
         public static EnergyDensity PetawattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static EnergyDensity PetawattHoursPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromPetawattHoursPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromTerajoulesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromTerajoulesPerCubicMeter(double)" />
         public static EnergyDensity TerajoulesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static EnergyDensity TerajoulesPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromTerajoulesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromTerawattHoursPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromTerawattHoursPerCubicMeter(double)" />
         public static EnergyDensity TerawattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static EnergyDensity TerawattHoursPerCubicMeter<T>(this T value)
 #endif
             => EnergyDensity.FromTerawattHoursPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="EnergyDensity.FromWattHoursPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="EnergyDensity.FromWattHoursPerCubicMeter(double)" />
         public static EnergyDensity WattHoursPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
index 57b559c185..e07186fad8 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEnergyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToEnergy
     /// </summary>
     public static class NumberToEnergyExtensions
     {
-        /// <inheritdoc cref="Energy.FromBritishThermalUnits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromBritishThermalUnits(double)" />
         public static Energy BritishThermalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Energy BritishThermalUnits<T>(this T value)
 #endif
             => Energy.FromBritishThermalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromCalories(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromCalories(double)" />
         public static Energy Calories<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Energy Calories<T>(this T value)
 #endif
             => Energy.FromCalories(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromDecathermsEc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromDecathermsEc(double)" />
         public static Energy DecathermsEc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Energy DecathermsEc<T>(this T value)
 #endif
             => Energy.FromDecathermsEc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromDecathermsImperial(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromDecathermsImperial(double)" />
         public static Energy DecathermsImperial<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Energy DecathermsImperial<T>(this T value)
 #endif
             => Energy.FromDecathermsImperial(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromDecathermsUs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromDecathermsUs(double)" />
         public static Energy DecathermsUs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Energy DecathermsUs<T>(this T value)
 #endif
             => Energy.FromDecathermsUs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromElectronVolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromElectronVolts(double)" />
         public static Energy ElectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Energy ElectronVolts<T>(this T value)
 #endif
             => Energy.FromElectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromErgs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromErgs(double)" />
         public static Energy Ergs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Energy Ergs<T>(this T value)
 #endif
             => Energy.FromErgs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromFootPounds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromFootPounds(double)" />
         public static Energy FootPounds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Energy FootPounds<T>(this T value)
 #endif
             => Energy.FromFootPounds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromGigabritishThermalUnits(double)" />
         public static Energy GigabritishThermalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Energy GigabritishThermalUnits<T>(this T value)
 #endif
             => Energy.FromGigabritishThermalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigaelectronVolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromGigaelectronVolts(double)" />
         public static Energy GigaelectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Energy GigaelectronVolts<T>(this T value)
 #endif
             => Energy.FromGigaelectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigajoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromGigajoules(double)" />
         public static Energy Gigajoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Energy Gigajoules<T>(this T value)
 #endif
             => Energy.FromGigajoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigawattDays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromGigawattDays(double)" />
         public static Energy GigawattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Energy GigawattDays<T>(this T value)
 #endif
             => Energy.FromGigawattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromGigawattHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromGigawattHours(double)" />
         public static Energy GigawattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Energy GigawattHours<T>(this T value)
 #endif
             => Energy.FromGigawattHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromHorsepowerHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromHorsepowerHours(double)" />
         public static Energy HorsepowerHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Energy HorsepowerHours<T>(this T value)
 #endif
             => Energy.FromHorsepowerHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromJoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromJoules(double)" />
         public static Energy Joules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Energy Joules<T>(this T value)
 #endif
             => Energy.FromJoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromKilobritishThermalUnits(double)" />
         public static Energy KilobritishThermalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Energy KilobritishThermalUnits<T>(this T value)
 #endif
             => Energy.FromKilobritishThermalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilocalories(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromKilocalories(double)" />
         public static Energy Kilocalories<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Energy Kilocalories<T>(this T value)
 #endif
             => Energy.FromKilocalories(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKiloelectronVolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromKiloelectronVolts(double)" />
         public static Energy KiloelectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Energy KiloelectronVolts<T>(this T value)
 #endif
             => Energy.FromKiloelectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilojoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromKilojoules(double)" />
         public static Energy Kilojoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Energy Kilojoules<T>(this T value)
 #endif
             => Energy.FromKilojoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilowattDays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromKilowattDays(double)" />
         public static Energy KilowattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Energy KilowattDays<T>(this T value)
 #endif
             => Energy.FromKilowattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromKilowattHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromKilowattHours(double)" />
         public static Energy KilowattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Energy KilowattHours<T>(this T value)
 #endif
             => Energy.FromKilowattHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromMegabritishThermalUnits(double)" />
         public static Energy MegabritishThermalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Energy MegabritishThermalUnits<T>(this T value)
 #endif
             => Energy.FromMegabritishThermalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegacalories(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromMegacalories(double)" />
         public static Energy Megacalories<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Energy Megacalories<T>(this T value)
 #endif
             => Energy.FromMegacalories(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegaelectronVolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromMegaelectronVolts(double)" />
         public static Energy MegaelectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Energy MegaelectronVolts<T>(this T value)
 #endif
             => Energy.FromMegaelectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegajoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromMegajoules(double)" />
         public static Energy Megajoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Energy Megajoules<T>(this T value)
 #endif
             => Energy.FromMegajoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegawattDays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromMegawattDays(double)" />
         public static Energy MegawattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static Energy MegawattDays<T>(this T value)
 #endif
             => Energy.FromMegawattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMegawattHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromMegawattHours(double)" />
         public static Energy MegawattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static Energy MegawattHours<T>(this T value)
 #endif
             => Energy.FromMegawattHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMicrojoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromMicrojoules(double)" />
         public static Energy Microjoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static Energy Microjoules<T>(this T value)
 #endif
             => Energy.FromMicrojoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromMillijoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromMillijoules(double)" />
         public static Energy Millijoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static Energy Millijoules<T>(this T value)
 #endif
             => Energy.FromMillijoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromNanojoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromNanojoules(double)" />
         public static Energy Nanojoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static Energy Nanojoules<T>(this T value)
 #endif
             => Energy.FromNanojoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromPetajoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromPetajoules(double)" />
         public static Energy Petajoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static Energy Petajoules<T>(this T value)
 #endif
             => Energy.FromPetajoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromTeraelectronVolts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromTeraelectronVolts(double)" />
         public static Energy TeraelectronVolts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static Energy TeraelectronVolts<T>(this T value)
 #endif
             => Energy.FromTeraelectronVolts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromTerajoules(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromTerajoules(double)" />
         public static Energy Terajoules<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static Energy Terajoules<T>(this T value)
 #endif
             => Energy.FromTerajoules(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromTerawattDays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromTerawattDays(double)" />
         public static Energy TerawattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static Energy TerawattDays<T>(this T value)
 #endif
             => Energy.FromTerawattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromTerawattHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromTerawattHours(double)" />
         public static Energy TerawattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static Energy TerawattHours<T>(this T value)
 #endif
             => Energy.FromTerawattHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromThermsEc(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromThermsEc(double)" />
         public static Energy ThermsEc<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static Energy ThermsEc<T>(this T value)
 #endif
             => Energy.FromThermsEc(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromThermsImperial(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromThermsImperial(double)" />
         public static Energy ThermsImperial<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static Energy ThermsImperial<T>(this T value)
 #endif
             => Energy.FromThermsImperial(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromThermsUs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromThermsUs(double)" />
         public static Energy ThermsUs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -336,7 +336,7 @@ public static Energy ThermsUs<T>(this T value)
 #endif
             => Energy.FromThermsUs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromWattDays(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromWattDays(double)" />
         public static Energy WattDays<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -344,7 +344,7 @@ public static Energy WattDays<T>(this T value)
 #endif
             => Energy.FromWattDays(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Energy.FromWattHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Energy.FromWattHours(double)" />
         public static Energy WattHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
index ebe9df9ae5..a0ccaf7096 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToEntropyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToEntropy
     /// </summary>
     public static class NumberToEntropyExtensions
     {
-        /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Entropy.FromCaloriesPerKelvin(double)" />
         public static Entropy CaloriesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Entropy CaloriesPerKelvin<T>(this T value)
 #endif
             => Entropy.FromCaloriesPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Entropy.FromJoulesPerDegreeCelsius(double)" />
         public static Entropy JoulesPerDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Entropy JoulesPerDegreeCelsius<T>(this T value)
 #endif
             => Entropy.FromJoulesPerDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Entropy.FromJoulesPerKelvin(double)" />
         public static Entropy JoulesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Entropy JoulesPerKelvin<T>(this T value)
 #endif
             => Entropy.FromJoulesPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Entropy.FromKilocaloriesPerKelvin(double)" />
         public static Entropy KilocaloriesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Entropy KilocaloriesPerKelvin<T>(this T value)
 #endif
             => Entropy.FromKilocaloriesPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Entropy.FromKilojoulesPerDegreeCelsius(double)" />
         public static Entropy KilojoulesPerDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Entropy KilojoulesPerDegreeCelsius<T>(this T value)
 #endif
             => Entropy.FromKilojoulesPerDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Entropy.FromKilojoulesPerKelvin(double)" />
         public static Entropy KilojoulesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Entropy KilojoulesPerKelvin<T>(this T value)
 #endif
             => Entropy.FromKilojoulesPerKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Entropy.FromMegajoulesPerKelvin(double)" />
         public static Entropy MegajoulesPerKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
index 4413dfc62b..1466c67707 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceChangeRateExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToForceChangeRate
     /// </summary>
     public static class NumberToForceChangeRateExtensions
     {
-        /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromCentinewtonsPerSecond(double)" />
         public static ForceChangeRate CentinewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ForceChangeRate CentinewtonsPerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromCentinewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerMinute(double)" />
         public static ForceChangeRate DecanewtonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ForceChangeRate DecanewtonsPerMinute<T>(this T value)
 #endif
             => ForceChangeRate.FromDecanewtonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromDecanewtonsPerSecond(double)" />
         public static ForceChangeRate DecanewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ForceChangeRate DecanewtonsPerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromDecanewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromDecinewtonsPerSecond(double)" />
         public static ForceChangeRate DecinewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ForceChangeRate DecinewtonsPerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromDecinewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerMinute(double)" />
         public static ForceChangeRate KilonewtonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ForceChangeRate KilonewtonsPerMinute<T>(this T value)
 #endif
             => ForceChangeRate.FromKilonewtonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromKilonewtonsPerSecond(double)" />
         public static ForceChangeRate KilonewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ForceChangeRate KilonewtonsPerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromKilonewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerMinute(double)" />
         public static ForceChangeRate KilopoundsForcePerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static ForceChangeRate KilopoundsForcePerMinute<T>(this T value)
 #endif
             => ForceChangeRate.FromKilopoundsForcePerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromKilopoundsForcePerSecond(double)" />
         public static ForceChangeRate KilopoundsForcePerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static ForceChangeRate KilopoundsForcePerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromKilopoundsForcePerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromMicronewtonsPerSecond(double)" />
         public static ForceChangeRate MicronewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static ForceChangeRate MicronewtonsPerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromMicronewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromMillinewtonsPerSecond(double)" />
         public static ForceChangeRate MillinewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static ForceChangeRate MillinewtonsPerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromMillinewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromNanonewtonsPerSecond(double)" />
         public static ForceChangeRate NanonewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static ForceChangeRate NanonewtonsPerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromNanonewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerMinute(double)" />
         public static ForceChangeRate NewtonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static ForceChangeRate NewtonsPerMinute<T>(this T value)
 #endif
             => ForceChangeRate.FromNewtonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromNewtonsPerSecond(double)" />
         public static ForceChangeRate NewtonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static ForceChangeRate NewtonsPerSecond<T>(this T value)
 #endif
             => ForceChangeRate.FromNewtonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerMinute(double)" />
         public static ForceChangeRate PoundsForcePerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static ForceChangeRate PoundsForcePerMinute<T>(this T value)
 #endif
             => ForceChangeRate.FromPoundsForcePerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForceChangeRate.FromPoundsForcePerSecond(double)" />
         public static ForceChangeRate PoundsForcePerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
index 3c27f851da..85f4b75944 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToForce
     /// </summary>
     public static class NumberToForceExtensions
     {
-        /// <inheritdoc cref="Force.FromDecanewtons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromDecanewtons(double)" />
         public static Force Decanewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Force Decanewtons<T>(this T value)
 #endif
             => Force.FromDecanewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromDyne(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromDyne(double)" />
         public static Force Dyne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Force Dyne<T>(this T value)
 #endif
             => Force.FromDyne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromKilogramsForce(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromKilogramsForce(double)" />
         public static Force KilogramsForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Force KilogramsForce<T>(this T value)
 #endif
             => Force.FromKilogramsForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromKilonewtons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromKilonewtons(double)" />
         public static Force Kilonewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Force Kilonewtons<T>(this T value)
 #endif
             => Force.FromKilonewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromKiloPonds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromKiloPonds(double)" />
         public static Force KiloPonds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Force KiloPonds<T>(this T value)
 #endif
             => Force.FromKiloPonds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromKilopoundsForce(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromKilopoundsForce(double)" />
         public static Force KilopoundsForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Force KilopoundsForce<T>(this T value)
 #endif
             => Force.FromKilopoundsForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromMeganewtons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromMeganewtons(double)" />
         public static Force Meganewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Force Meganewtons<T>(this T value)
 #endif
             => Force.FromMeganewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromMicronewtons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromMicronewtons(double)" />
         public static Force Micronewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Force Micronewtons<T>(this T value)
 #endif
             => Force.FromMicronewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromMillinewtons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromMillinewtons(double)" />
         public static Force Millinewtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Force Millinewtons<T>(this T value)
 #endif
             => Force.FromMillinewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromNewtons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromNewtons(double)" />
         public static Force Newtons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Force Newtons<T>(this T value)
 #endif
             => Force.FromNewtons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromOunceForce(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromOunceForce(double)" />
         public static Force OunceForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Force OunceForce<T>(this T value)
 #endif
             => Force.FromOunceForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromPoundals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromPoundals(double)" />
         public static Force Poundals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Force Poundals<T>(this T value)
 #endif
             => Force.FromPoundals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromPoundsForce(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromPoundsForce(double)" />
         public static Force PoundsForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Force PoundsForce<T>(this T value)
 #endif
             => Force.FromPoundsForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromShortTonsForce(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromShortTonsForce(double)" />
         public static Force ShortTonsForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Force ShortTonsForce<T>(this T value)
 #endif
             => Force.FromShortTonsForce(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Force.FromTonnesForce(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Force.FromTonnesForce(double)" />
         public static Force TonnesForce<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
index ee3a0f03b6..d506a693a6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToForcePerLengthExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToForcePerLength
     /// </summary>
     public static class NumberToForcePerLengthExtensions
     {
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerCentimeter(double)" />
         public static ForcePerLength CentinewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ForcePerLength CentinewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromCentinewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMeter(double)" />
         public static ForcePerLength CentinewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ForcePerLength CentinewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromCentinewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromCentinewtonsPerMillimeter(double)" />
         public static ForcePerLength CentinewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ForcePerLength CentinewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromCentinewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerCentimeter(double)" />
         public static ForcePerLength DecanewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ForcePerLength DecanewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromDecanewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMeter(double)" />
         public static ForcePerLength DecanewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ForcePerLength DecanewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromDecanewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecanewtonsPerMillimeter(double)" />
         public static ForcePerLength DecanewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ForcePerLength DecanewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromDecanewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerCentimeter(double)" />
         public static ForcePerLength DecinewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static ForcePerLength DecinewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromDecinewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMeter(double)" />
         public static ForcePerLength DecinewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static ForcePerLength DecinewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromDecinewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromDecinewtonsPerMillimeter(double)" />
         public static ForcePerLength DecinewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static ForcePerLength DecinewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromDecinewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerCentimeter(double)" />
         public static ForcePerLength KilogramsForcePerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static ForcePerLength KilogramsForcePerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromKilogramsForcePerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMeter(double)" />
         public static ForcePerLength KilogramsForcePerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static ForcePerLength KilogramsForcePerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromKilogramsForcePerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilogramsForcePerMillimeter(double)" />
         public static ForcePerLength KilogramsForcePerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static ForcePerLength KilogramsForcePerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromKilogramsForcePerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerCentimeter(double)" />
         public static ForcePerLength KilonewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static ForcePerLength KilonewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromKilonewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMeter(double)" />
         public static ForcePerLength KilonewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static ForcePerLength KilonewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromKilonewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilonewtonsPerMillimeter(double)" />
         public static ForcePerLength KilonewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static ForcePerLength KilonewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromKilonewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerFoot(double)" />
         public static ForcePerLength KilopoundsForcePerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static ForcePerLength KilopoundsForcePerFoot<T>(this T value)
 #endif
             => ForcePerLength.FromKilopoundsForcePerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromKilopoundsForcePerInch(double)" />
         public static ForcePerLength KilopoundsForcePerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static ForcePerLength KilopoundsForcePerInch<T>(this T value)
 #endif
             => ForcePerLength.FromKilopoundsForcePerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerCentimeter(double)" />
         public static ForcePerLength MeganewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static ForcePerLength MeganewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromMeganewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMeter(double)" />
         public static ForcePerLength MeganewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static ForcePerLength MeganewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromMeganewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMeganewtonsPerMillimeter(double)" />
         public static ForcePerLength MeganewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static ForcePerLength MeganewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromMeganewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerCentimeter(double)" />
         public static ForcePerLength MicronewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static ForcePerLength MicronewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromMicronewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMeter(double)" />
         public static ForcePerLength MicronewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static ForcePerLength MicronewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromMicronewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMicronewtonsPerMillimeter(double)" />
         public static ForcePerLength MicronewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static ForcePerLength MicronewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromMicronewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerCentimeter(double)" />
         public static ForcePerLength MillinewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static ForcePerLength MillinewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromMillinewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMeter(double)" />
         public static ForcePerLength MillinewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static ForcePerLength MillinewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromMillinewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromMillinewtonsPerMillimeter(double)" />
         public static ForcePerLength MillinewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static ForcePerLength MillinewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromMillinewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerCentimeter(double)" />
         public static ForcePerLength NanonewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static ForcePerLength NanonewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromNanonewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMeter(double)" />
         public static ForcePerLength NanonewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static ForcePerLength NanonewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromNanonewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromNanonewtonsPerMillimeter(double)" />
         public static ForcePerLength NanonewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static ForcePerLength NanonewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromNanonewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerCentimeter(double)" />
         public static ForcePerLength NewtonsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static ForcePerLength NewtonsPerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromNewtonsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMeter(double)" />
         public static ForcePerLength NewtonsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static ForcePerLength NewtonsPerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromNewtonsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromNewtonsPerMillimeter(double)" />
         public static ForcePerLength NewtonsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static ForcePerLength NewtonsPerMillimeter<T>(this T value)
 #endif
             => ForcePerLength.FromNewtonsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerFoot(double)" />
         public static ForcePerLength PoundsForcePerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static ForcePerLength PoundsForcePerFoot<T>(this T value)
 #endif
             => ForcePerLength.FromPoundsForcePerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerInch(double)" />
         public static ForcePerLength PoundsForcePerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static ForcePerLength PoundsForcePerInch<T>(this T value)
 #endif
             => ForcePerLength.FromPoundsForcePerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromPoundsForcePerYard(double)" />
         public static ForcePerLength PoundsForcePerYard<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static ForcePerLength PoundsForcePerYard<T>(this T value)
 #endif
             => ForcePerLength.FromPoundsForcePerYard(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerCentimeter(double)" />
         public static ForcePerLength TonnesForcePerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static ForcePerLength TonnesForcePerCentimeter<T>(this T value)
 #endif
             => ForcePerLength.FromTonnesForcePerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMeter(double)" />
         public static ForcePerLength TonnesForcePerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static ForcePerLength TonnesForcePerMeter<T>(this T value)
 #endif
             => ForcePerLength.FromTonnesForcePerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ForcePerLength.FromTonnesForcePerMillimeter(double)" />
         public static ForcePerLength TonnesForcePerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
index 9c2b622b1c..3839b85f8b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFrequencyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToFrequency
     /// </summary>
     public static class NumberToFrequencyExtensions
     {
-        /// <inheritdoc cref="Frequency.FromBeatsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromBeatsPerMinute(double)" />
         public static Frequency BeatsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Frequency BeatsPerMinute<T>(this T value)
 #endif
             => Frequency.FromBeatsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromBUnits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromBUnits(double)" />
         public static Frequency BUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Frequency BUnits<T>(this T value)
 #endif
             => Frequency.FromBUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromCyclesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromCyclesPerHour(double)" />
         public static Frequency CyclesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Frequency CyclesPerHour<T>(this T value)
 #endif
             => Frequency.FromCyclesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromCyclesPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromCyclesPerMinute(double)" />
         public static Frequency CyclesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Frequency CyclesPerMinute<T>(this T value)
 #endif
             => Frequency.FromCyclesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromGigahertz(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromGigahertz(double)" />
         public static Frequency Gigahertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Frequency Gigahertz<T>(this T value)
 #endif
             => Frequency.FromGigahertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromHertz(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromHertz(double)" />
         public static Frequency Hertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Frequency Hertz<T>(this T value)
 #endif
             => Frequency.FromHertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromKilohertz(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromKilohertz(double)" />
         public static Frequency Kilohertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Frequency Kilohertz<T>(this T value)
 #endif
             => Frequency.FromKilohertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromMegahertz(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromMegahertz(double)" />
         public static Frequency Megahertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Frequency Megahertz<T>(this T value)
 #endif
             => Frequency.FromMegahertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromMicrohertz(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromMicrohertz(double)" />
         public static Frequency Microhertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Frequency Microhertz<T>(this T value)
 #endif
             => Frequency.FromMicrohertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromMillihertz(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromMillihertz(double)" />
         public static Frequency Millihertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Frequency Millihertz<T>(this T value)
 #endif
             => Frequency.FromMillihertz(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromPerSecond(double)" />
         public static Frequency PerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Frequency PerSecond<T>(this T value)
 #endif
             => Frequency.FromPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromRadiansPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromRadiansPerSecond(double)" />
         public static Frequency RadiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Frequency RadiansPerSecond<T>(this T value)
 #endif
             => Frequency.FromRadiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Frequency.FromTerahertz(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Frequency.FromTerahertz(double)" />
         public static Frequency Terahertz<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
index e7681b8ef9..c2db1d3139 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToFuelEfficiencyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToFuelEfficiency
     /// </summary>
     public static class NumberToFuelEfficiencyExtensions
     {
-        /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="FuelEfficiency.FromKilometersPerLiter(double)" />
         public static FuelEfficiency KilometersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static FuelEfficiency KilometersPerLiter<T>(this T value)
 #endif
             => FuelEfficiency.FromKilometersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="FuelEfficiency.FromLitersPer100Kilometers(double)" />
         public static FuelEfficiency LitersPer100Kilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static FuelEfficiency LitersPer100Kilometers<T>(this T value)
 #endif
             => FuelEfficiency.FromLitersPer100Kilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUkGallon(double)" />
         public static FuelEfficiency MilesPerUkGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static FuelEfficiency MilesPerUkGallon<T>(this T value)
 #endif
             => FuelEfficiency.FromMilesPerUkGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="FuelEfficiency.FromMilesPerUsGallon(double)" />
         public static FuelEfficiency MilesPerUsGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
index 7ee2a64422..6039addde3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatFluxExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToHeatFlux
     /// </summary>
     public static class NumberToHeatFluxExtensions
     {
-        /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromBtusPerHourSquareFoot(double)" />
         public static HeatFlux BtusPerHourSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static HeatFlux BtusPerHourSquareFoot<T>(this T value)
 #endif
             => HeatFlux.FromBtusPerHourSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromBtusPerMinuteSquareFoot(double)" />
         public static HeatFlux BtusPerMinuteSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static HeatFlux BtusPerMinuteSquareFoot<T>(this T value)
 #endif
             => HeatFlux.FromBtusPerMinuteSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareFoot(double)" />
         public static HeatFlux BtusPerSecondSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static HeatFlux BtusPerSecondSquareFoot<T>(this T value)
 #endif
             => HeatFlux.FromBtusPerSecondSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromBtusPerSecondSquareInch(double)" />
         public static HeatFlux BtusPerSecondSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static HeatFlux BtusPerSecondSquareInch<T>(this T value)
 #endif
             => HeatFlux.FromBtusPerSecondSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromCaloriesPerSecondSquareCentimeter(double)" />
         public static HeatFlux CaloriesPerSecondSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static HeatFlux CaloriesPerSecondSquareCentimeter<T>(this T value)
 #endif
             => HeatFlux.FromCaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromCentiwattsPerSquareMeter(double)" />
         public static HeatFlux CentiwattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static HeatFlux CentiwattsPerSquareMeter<T>(this T value)
 #endif
             => HeatFlux.FromCentiwattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromDeciwattsPerSquareMeter(double)" />
         public static HeatFlux DeciwattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static HeatFlux DeciwattsPerSquareMeter<T>(this T value)
 #endif
             => HeatFlux.FromDeciwattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerHourSquareMeter(double)" />
         public static HeatFlux KilocaloriesPerHourSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static HeatFlux KilocaloriesPerHourSquareMeter<T>(this T value)
 #endif
             => HeatFlux.FromKilocaloriesPerHourSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(double)" />
         public static HeatFlux KilocaloriesPerSecondSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static HeatFlux KilocaloriesPerSecondSquareCentimeter<T>(this T value)
 #endif
             => HeatFlux.FromKilocaloriesPerSecondSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromKilowattsPerSquareMeter(double)" />
         public static HeatFlux KilowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static HeatFlux KilowattsPerSquareMeter<T>(this T value)
 #endif
             => HeatFlux.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromMicrowattsPerSquareMeter(double)" />
         public static HeatFlux MicrowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static HeatFlux MicrowattsPerSquareMeter<T>(this T value)
 #endif
             => HeatFlux.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromMilliwattsPerSquareMeter(double)" />
         public static HeatFlux MilliwattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static HeatFlux MilliwattsPerSquareMeter<T>(this T value)
 #endif
             => HeatFlux.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromNanowattsPerSquareMeter(double)" />
         public static HeatFlux NanowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static HeatFlux NanowattsPerSquareMeter<T>(this T value)
 #endif
             => HeatFlux.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromPoundsForcePerFootSecond(double)" />
         public static HeatFlux PoundsForcePerFootSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static HeatFlux PoundsForcePerFootSecond<T>(this T value)
 #endif
             => HeatFlux.FromPoundsForcePerFootSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromPoundsPerSecondCubed(double)" />
         public static HeatFlux PoundsPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static HeatFlux PoundsPerSecondCubed<T>(this T value)
 #endif
             => HeatFlux.FromPoundsPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareFoot(double)" />
         public static HeatFlux WattsPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static HeatFlux WattsPerSquareFoot<T>(this T value)
 #endif
             => HeatFlux.FromWattsPerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareInch(double)" />
         public static HeatFlux WattsPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static HeatFlux WattsPerSquareInch<T>(this T value)
 #endif
             => HeatFlux.FromWattsPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatFlux.FromWattsPerSquareMeter(double)" />
         public static HeatFlux WattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
index d0beae1f96..d53c217c5f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToHeatTransferCoefficientExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToHeatTransferCoefficient
     /// </summary>
     public static class NumberToHeatTransferCoefficientExtensions
     {
-        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(double)" />
         public static HeatTransferCoefficient BtusPerHourSquareFootDegreeFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static HeatTransferCoefficient BtusPerHourSquareFootDegreeFahrenheit<T>(t
 #endif
             => HeatTransferCoefficient.FromBtusPerHourSquareFootDegreeFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(double)" />
         [Obsolete("The name of this definition incorrectly omitted time as divisor, please use BtuPerHourSquareFootDegreeFahrenheit instead")]
         public static HeatTransferCoefficient BtusPerSquareFootDegreeFahrenheit<T>(this T value)
             where T : notnull
@@ -49,7 +49,7 @@ public static HeatTransferCoefficient BtusPerSquareFootDegreeFahrenheit<T>(this
 #endif
             => HeatTransferCoefficient.FromBtusPerSquareFootDegreeFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(double)" />
         public static HeatTransferCoefficient CaloriesPerHourSquareMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -57,7 +57,7 @@ public static HeatTransferCoefficient CaloriesPerHourSquareMeterDegreeCelsius<T>
 #endif
             => HeatTransferCoefficient.FromCaloriesPerHourSquareMeterDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(double)" />
         public static HeatTransferCoefficient KilocaloriesPerHourSquareMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -65,7 +65,7 @@ public static HeatTransferCoefficient KilocaloriesPerHourSquareMeterDegreeCelsiu
 #endif
             => HeatTransferCoefficient.FromKilocaloriesPerHourSquareMeterDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(double)" />
         public static HeatTransferCoefficient WattsPerSquareMeterCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -73,7 +73,7 @@ public static HeatTransferCoefficient WattsPerSquareMeterCelsius<T>(this T value
 #endif
             => HeatTransferCoefficient.FromWattsPerSquareMeterCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="HeatTransferCoefficient.FromWattsPerSquareMeterKelvin(double)" />
         public static HeatTransferCoefficient WattsPerSquareMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
index 9e16ed4717..e901c49a6a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIlluminanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToIlluminance
     /// </summary>
     public static class NumberToIlluminanceExtensions
     {
-        /// <inheritdoc cref="Illuminance.FromKilolux(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Illuminance.FromKilolux(double)" />
         public static Illuminance Kilolux<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Illuminance Kilolux<T>(this T value)
 #endif
             => Illuminance.FromKilolux(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Illuminance.FromLux(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Illuminance.FromLux(double)" />
         public static Illuminance Lux<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Illuminance Lux<T>(this T value)
 #endif
             => Illuminance.FromLux(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Illuminance.FromMegalux(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Illuminance.FromMegalux(double)" />
         public static Illuminance Megalux<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Illuminance Megalux<T>(this T value)
 #endif
             => Illuminance.FromMegalux(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Illuminance.FromMillilux(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Illuminance.FromMillilux(double)" />
         public static Illuminance Millilux<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToImpulseExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToImpulseExtensions.g.cs
index f72852c086..8e48e38d3a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToImpulseExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToImpulseExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToImpulse
     /// </summary>
     public static class NumberToImpulseExtensions
     {
-        /// <inheritdoc cref="Impulse.FromCentinewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromCentinewtonSeconds(double)" />
         public static Impulse CentinewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Impulse CentinewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromCentinewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromDecanewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromDecanewtonSeconds(double)" />
         public static Impulse DecanewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Impulse DecanewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromDecanewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromDecinewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromDecinewtonSeconds(double)" />
         public static Impulse DecinewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Impulse DecinewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromDecinewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromKilogramMetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromKilogramMetersPerSecond(double)" />
         public static Impulse KilogramMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Impulse KilogramMetersPerSecond<T>(this T value)
 #endif
             => Impulse.FromKilogramMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromKilonewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromKilonewtonSeconds(double)" />
         public static Impulse KilonewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Impulse KilonewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromKilonewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromMeganewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromMeganewtonSeconds(double)" />
         public static Impulse MeganewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Impulse MeganewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromMeganewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromMicronewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromMicronewtonSeconds(double)" />
         public static Impulse MicronewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Impulse MicronewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromMicronewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromMillinewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromMillinewtonSeconds(double)" />
         public static Impulse MillinewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Impulse MillinewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromMillinewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromNanonewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromNanonewtonSeconds(double)" />
         public static Impulse NanonewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Impulse NanonewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromNanonewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromNewtonSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromNewtonSeconds(double)" />
         public static Impulse NewtonSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Impulse NewtonSeconds<T>(this T value)
 #endif
             => Impulse.FromNewtonSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromPoundFeetPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromPoundFeetPerSecond(double)" />
         public static Impulse PoundFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Impulse PoundFeetPerSecond<T>(this T value)
 #endif
             => Impulse.FromPoundFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromPoundForceSeconds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromPoundForceSeconds(double)" />
         public static Impulse PoundForceSeconds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Impulse PoundForceSeconds<T>(this T value)
 #endif
             => Impulse.FromPoundForceSeconds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Impulse.FromSlugFeetPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Impulse.FromSlugFeetPerSecond(double)" />
         public static Impulse SlugFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
index d43d63c0a4..f8251dc677 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToInformationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToInformation
     /// </summary>
     public static class NumberToInformationExtensions
     {
-        /// <inheritdoc cref="Information.FromBits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromBits(double)" />
         public static Information Bits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Information Bits<T>(this T value)
 #endif
             => Information.FromBits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromBytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromBytes(double)" />
         public static Information Bytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Information Bytes<T>(this T value)
 #endif
             => Information.FromBytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromExabits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromExabits(double)" />
         public static Information Exabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Information Exabits<T>(this T value)
 #endif
             => Information.FromExabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromExabytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromExabytes(double)" />
         public static Information Exabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Information Exabytes<T>(this T value)
 #endif
             => Information.FromExabytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromExbibits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromExbibits(double)" />
         public static Information Exbibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Information Exbibits<T>(this T value)
 #endif
             => Information.FromExbibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromExbibytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromExbibytes(double)" />
         public static Information Exbibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Information Exbibytes<T>(this T value)
 #endif
             => Information.FromExbibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromGibibits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromGibibits(double)" />
         public static Information Gibibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Information Gibibits<T>(this T value)
 #endif
             => Information.FromGibibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromGibibytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromGibibytes(double)" />
         public static Information Gibibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Information Gibibytes<T>(this T value)
 #endif
             => Information.FromGibibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromGigabits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromGigabits(double)" />
         public static Information Gigabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Information Gigabits<T>(this T value)
 #endif
             => Information.FromGigabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromGigabytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromGigabytes(double)" />
         public static Information Gigabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Information Gigabytes<T>(this T value)
 #endif
             => Information.FromGigabytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromKibibits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromKibibits(double)" />
         public static Information Kibibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Information Kibibits<T>(this T value)
 #endif
             => Information.FromKibibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromKibibytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromKibibytes(double)" />
         public static Information Kibibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Information Kibibytes<T>(this T value)
 #endif
             => Information.FromKibibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromKilobits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromKilobits(double)" />
         public static Information Kilobits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Information Kilobits<T>(this T value)
 #endif
             => Information.FromKilobits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromKilobytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromKilobytes(double)" />
         public static Information Kilobytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Information Kilobytes<T>(this T value)
 #endif
             => Information.FromKilobytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromMebibits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromMebibits(double)" />
         public static Information Mebibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Information Mebibits<T>(this T value)
 #endif
             => Information.FromMebibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromMebibytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromMebibytes(double)" />
         public static Information Mebibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Information Mebibytes<T>(this T value)
 #endif
             => Information.FromMebibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromMegabits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromMegabits(double)" />
         public static Information Megabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Information Megabits<T>(this T value)
 #endif
             => Information.FromMegabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromMegabytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromMegabytes(double)" />
         public static Information Megabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Information Megabytes<T>(this T value)
 #endif
             => Information.FromMegabytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromPebibits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromPebibits(double)" />
         public static Information Pebibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Information Pebibits<T>(this T value)
 #endif
             => Information.FromPebibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromPebibytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromPebibytes(double)" />
         public static Information Pebibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Information Pebibytes<T>(this T value)
 #endif
             => Information.FromPebibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromPetabits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromPetabits(double)" />
         public static Information Petabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Information Petabits<T>(this T value)
 #endif
             => Information.FromPetabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromPetabytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromPetabytes(double)" />
         public static Information Petabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Information Petabytes<T>(this T value)
 #endif
             => Information.FromPetabytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromTebibits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromTebibits(double)" />
         public static Information Tebibits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Information Tebibits<T>(this T value)
 #endif
             => Information.FromTebibits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromTebibytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromTebibytes(double)" />
         public static Information Tebibytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Information Tebibytes<T>(this T value)
 #endif
             => Information.FromTebibytes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromTerabits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromTerabits(double)" />
         public static Information Terabits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Information Terabits<T>(this T value)
 #endif
             => Information.FromTerabits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Information.FromTerabytes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Information.FromTerabytes(double)" />
         public static Information Terabytes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
index 90074f863a..cd54959d81 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradianceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToIrradiance
     /// </summary>
     public static class NumberToIrradianceExtensions
     {
-        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareCentimeter(double)" />
         public static Irradiance KilowattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Irradiance KilowattsPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiance.FromKilowattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromKilowattsPerSquareMeter(double)" />
         public static Irradiance KilowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Irradiance KilowattsPerSquareMeter<T>(this T value)
 #endif
             => Irradiance.FromKilowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareCentimeter(double)" />
         public static Irradiance MegawattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Irradiance MegawattsPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiance.FromMegawattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromMegawattsPerSquareMeter(double)" />
         public static Irradiance MegawattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Irradiance MegawattsPerSquareMeter<T>(this T value)
 #endif
             => Irradiance.FromMegawattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareCentimeter(double)" />
         public static Irradiance MicrowattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Irradiance MicrowattsPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiance.FromMicrowattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromMicrowattsPerSquareMeter(double)" />
         public static Irradiance MicrowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Irradiance MicrowattsPerSquareMeter<T>(this T value)
 #endif
             => Irradiance.FromMicrowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareCentimeter(double)" />
         public static Irradiance MilliwattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Irradiance MilliwattsPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiance.FromMilliwattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromMilliwattsPerSquareMeter(double)" />
         public static Irradiance MilliwattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Irradiance MilliwattsPerSquareMeter<T>(this T value)
 #endif
             => Irradiance.FromMilliwattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareCentimeter(double)" />
         public static Irradiance NanowattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Irradiance NanowattsPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiance.FromNanowattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromNanowattsPerSquareMeter(double)" />
         public static Irradiance NanowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Irradiance NanowattsPerSquareMeter<T>(this T value)
 #endif
             => Irradiance.FromNanowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareCentimeter(double)" />
         public static Irradiance PicowattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Irradiance PicowattsPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiance.FromPicowattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromPicowattsPerSquareMeter(double)" />
         public static Irradiance PicowattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Irradiance PicowattsPerSquareMeter<T>(this T value)
 #endif
             => Irradiance.FromPicowattsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromWattsPerSquareCentimeter(double)" />
         public static Irradiance WattsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Irradiance WattsPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiance.FromWattsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiance.FromWattsPerSquareMeter(double)" />
         public static Irradiance WattsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
index 6d9d3433b5..56c114cc94 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToIrradiationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToIrradiation
     /// </summary>
     public static class NumberToIrradiationExtensions
     {
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareCentimeter(double)" />
         public static Irradiation JoulesPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Irradiation JoulesPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiation.FromJoulesPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMeter(double)" />
         public static Irradiation JoulesPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Irradiation JoulesPerSquareMeter<T>(this T value)
 #endif
             => Irradiation.FromJoulesPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiation.FromJoulesPerSquareMillimeter(double)" />
         public static Irradiation JoulesPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Irradiation JoulesPerSquareMillimeter<T>(this T value)
 #endif
             => Irradiation.FromJoulesPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiation.FromKilojoulesPerSquareMeter(double)" />
         public static Irradiation KilojoulesPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Irradiation KilojoulesPerSquareMeter<T>(this T value)
 #endif
             => Irradiation.FromKilojoulesPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiation.FromKilowattHoursPerSquareMeter(double)" />
         public static Irradiation KilowattHoursPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Irradiation KilowattHoursPerSquareMeter<T>(this T value)
 #endif
             => Irradiation.FromKilowattHoursPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiation.FromMillijoulesPerSquareCentimeter(double)" />
         public static Irradiation MillijoulesPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Irradiation MillijoulesPerSquareCentimeter<T>(this T value)
 #endif
             => Irradiation.FromMillijoulesPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Irradiation.FromWattHoursPerSquareMeter(double)" />
         public static Irradiation WattHoursPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToJerkExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToJerkExtensions.g.cs
index 00c604449c..fca1b8986b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToJerkExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToJerkExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToJerk
     /// </summary>
     public static class NumberToJerkExtensions
     {
-        /// <inheritdoc cref="Jerk.FromCentimetersPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromCentimetersPerSecondCubed(double)" />
         public static Jerk CentimetersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Jerk CentimetersPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromCentimetersPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromDecimetersPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromDecimetersPerSecondCubed(double)" />
         public static Jerk DecimetersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Jerk DecimetersPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromDecimetersPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromFeetPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromFeetPerSecondCubed(double)" />
         public static Jerk FeetPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Jerk FeetPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromFeetPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromInchesPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromInchesPerSecondCubed(double)" />
         public static Jerk InchesPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Jerk InchesPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromInchesPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromKilometersPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromKilometersPerSecondCubed(double)" />
         public static Jerk KilometersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Jerk KilometersPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromKilometersPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromMetersPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromMetersPerSecondCubed(double)" />
         public static Jerk MetersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Jerk MetersPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromMetersPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromMicrometersPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromMicrometersPerSecondCubed(double)" />
         public static Jerk MicrometersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Jerk MicrometersPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromMicrometersPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromMillimetersPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromMillimetersPerSecondCubed(double)" />
         public static Jerk MillimetersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Jerk MillimetersPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromMillimetersPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromMillistandardGravitiesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromMillistandardGravitiesPerSecond(double)" />
         public static Jerk MillistandardGravitiesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Jerk MillistandardGravitiesPerSecond<T>(this T value)
 #endif
             => Jerk.FromMillistandardGravitiesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromNanometersPerSecondCubed(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromNanometersPerSecondCubed(double)" />
         public static Jerk NanometersPerSecondCubed<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Jerk NanometersPerSecondCubed<T>(this T value)
 #endif
             => Jerk.FromNanometersPerSecondCubed(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Jerk.FromStandardGravitiesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Jerk.FromStandardGravitiesPerSecond(double)" />
         public static Jerk StandardGravitiesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
index c6f8cb7b69..c6f829f8cd 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToKinematicViscosityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToKinematicViscosity
     /// </summary>
     public static class NumberToKinematicViscosityExtensions
     {
-        /// <inheritdoc cref="KinematicViscosity.FromCentistokes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromCentistokes(double)" />
         public static KinematicViscosity Centistokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static KinematicViscosity Centistokes<T>(this T value)
 #endif
             => KinematicViscosity.FromCentistokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromDecistokes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromDecistokes(double)" />
         public static KinematicViscosity Decistokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static KinematicViscosity Decistokes<T>(this T value)
 #endif
             => KinematicViscosity.FromDecistokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromKilostokes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromKilostokes(double)" />
         public static KinematicViscosity Kilostokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static KinematicViscosity Kilostokes<T>(this T value)
 #endif
             => KinematicViscosity.FromKilostokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromMicrostokes(double)" />
         public static KinematicViscosity Microstokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static KinematicViscosity Microstokes<T>(this T value)
 #endif
             => KinematicViscosity.FromMicrostokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromMillistokes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromMillistokes(double)" />
         public static KinematicViscosity Millistokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static KinematicViscosity Millistokes<T>(this T value)
 #endif
             => KinematicViscosity.FromMillistokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromNanostokes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromNanostokes(double)" />
         public static KinematicViscosity Nanostokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static KinematicViscosity Nanostokes<T>(this T value)
 #endif
             => KinematicViscosity.FromNanostokes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromSquareFeetPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromSquareFeetPerSecond(double)" />
         public static KinematicViscosity SquareFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static KinematicViscosity SquareFeetPerSecond<T>(this T value)
 #endif
             => KinematicViscosity.FromSquareFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromSquareMetersPerSecond(double)" />
         public static KinematicViscosity SquareMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static KinematicViscosity SquareMetersPerSecond<T>(this T value)
 #endif
             => KinematicViscosity.FromSquareMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="KinematicViscosity.FromStokes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="KinematicViscosity.FromStokes(double)" />
         public static KinematicViscosity Stokes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLeakRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLeakRateExtensions.g.cs
index 16d6906baf..da9bdbf25d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLeakRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLeakRateExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLeakRate
     /// </summary>
     public static class NumberToLeakRateExtensions
     {
-        /// <inheritdoc cref="LeakRate.FromMillibarLitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LeakRate.FromMillibarLitersPerSecond(double)" />
         public static LeakRate MillibarLitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static LeakRate MillibarLitersPerSecond<T>(this T value)
 #endif
             => LeakRate.FromMillibarLitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LeakRate.FromPascalCubicMetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LeakRate.FromPascalCubicMetersPerSecond(double)" />
         public static LeakRate PascalCubicMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static LeakRate PascalCubicMetersPerSecond<T>(this T value)
 #endif
             => LeakRate.FromPascalCubicMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LeakRate.FromTorrLitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LeakRate.FromTorrLitersPerSecond(double)" />
         public static LeakRate TorrLitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
index 43fd3f376a..d15563ea80 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLengthExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLength
     /// </summary>
     public static class NumberToLengthExtensions
     {
-        /// <inheritdoc cref="Length.FromAngstroms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromAngstroms(double)" />
         public static Length Angstroms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Length Angstroms<T>(this T value)
 #endif
             => Length.FromAngstroms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromAstronomicalUnits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromAstronomicalUnits(double)" />
         public static Length AstronomicalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Length AstronomicalUnits<T>(this T value)
 #endif
             => Length.FromAstronomicalUnits(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromCentimeters(double)" />
         public static Length Centimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Length Centimeters<T>(this T value)
 #endif
             => Length.FromCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromChains(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromChains(double)" />
         public static Length Chains<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Length Chains<T>(this T value)
 #endif
             => Length.FromChains(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromDataMiles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromDataMiles(double)" />
         public static Length DataMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Length DataMiles<T>(this T value)
 #endif
             => Length.FromDataMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromDecameters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromDecameters(double)" />
         public static Length Decameters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Length Decameters<T>(this T value)
 #endif
             => Length.FromDecameters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromDecimeters(double)" />
         public static Length Decimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Length Decimeters<T>(this T value)
 #endif
             => Length.FromDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromDtpPicas(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromDtpPicas(double)" />
         public static Length DtpPicas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Length DtpPicas<T>(this T value)
 #endif
             => Length.FromDtpPicas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromDtpPoints(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromDtpPoints(double)" />
         public static Length DtpPoints<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Length DtpPoints<T>(this T value)
 #endif
             => Length.FromDtpPoints(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromFathoms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromFathoms(double)" />
         public static Length Fathoms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Length Fathoms<T>(this T value)
 #endif
             => Length.FromFathoms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromFemtometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromFemtometers(double)" />
         public static Length Femtometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Length Femtometers<T>(this T value)
 #endif
             => Length.FromFemtometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromFeet(double)" />
         public static Length Feet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Length Feet<T>(this T value)
 #endif
             => Length.FromFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromGigameters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromGigameters(double)" />
         public static Length Gigameters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Length Gigameters<T>(this T value)
 #endif
             => Length.FromGigameters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromHands(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromHands(double)" />
         public static Length Hands<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Length Hands<T>(this T value)
 #endif
             => Length.FromHands(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromHectometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromHectometers(double)" />
         public static Length Hectometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Length Hectometers<T>(this T value)
 #endif
             => Length.FromHectometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromInches(double)" />
         public static Length Inches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Length Inches<T>(this T value)
 #endif
             => Length.FromInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromKilofeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromKilofeet(double)" />
         public static Length Kilofeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Length Kilofeet<T>(this T value)
 #endif
             => Length.FromKilofeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromKilolightYears(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromKilolightYears(double)" />
         public static Length KilolightYears<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Length KilolightYears<T>(this T value)
 #endif
             => Length.FromKilolightYears(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromKilometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromKilometers(double)" />
         public static Length Kilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Length Kilometers<T>(this T value)
 #endif
             => Length.FromKilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromKiloparsecs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromKiloparsecs(double)" />
         public static Length Kiloparsecs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Length Kiloparsecs<T>(this T value)
 #endif
             => Length.FromKiloparsecs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromKiloyards(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromKiloyards(double)" />
         public static Length Kiloyards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Length Kiloyards<T>(this T value)
 #endif
             => Length.FromKiloyards(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromLightYears(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromLightYears(double)" />
         public static Length LightYears<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Length LightYears<T>(this T value)
 #endif
             => Length.FromLightYears(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMegalightYears(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMegalightYears(double)" />
         public static Length MegalightYears<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Length MegalightYears<T>(this T value)
 #endif
             => Length.FromMegalightYears(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMegameters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMegameters(double)" />
         public static Length Megameters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Length Megameters<T>(this T value)
 #endif
             => Length.FromMegameters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMegaparsecs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMegaparsecs(double)" />
         public static Length Megaparsecs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Length Megaparsecs<T>(this T value)
 #endif
             => Length.FromMegaparsecs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMeters(double)" />
         public static Length Meters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static Length Meters<T>(this T value)
 #endif
             => Length.FromMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMicroinches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMicroinches(double)" />
         public static Length Microinches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static Length Microinches<T>(this T value)
 #endif
             => Length.FromMicroinches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMicrometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMicrometers(double)" />
         public static Length Micrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static Length Micrometers<T>(this T value)
 #endif
             => Length.FromMicrometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMils(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMils(double)" />
         public static Length Mils<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static Length Mils<T>(this T value)
 #endif
             => Length.FromMils(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMiles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMiles(double)" />
         public static Length Miles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static Length Miles<T>(this T value)
 #endif
             => Length.FromMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromMillimeters(double)" />
         public static Length Millimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static Length Millimeters<T>(this T value)
 #endif
             => Length.FromMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromNanometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromNanometers(double)" />
         public static Length Nanometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static Length Nanometers<T>(this T value)
 #endif
             => Length.FromNanometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromNauticalMiles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromNauticalMiles(double)" />
         public static Length NauticalMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static Length NauticalMiles<T>(this T value)
 #endif
             => Length.FromNauticalMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromParsecs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromParsecs(double)" />
         public static Length Parsecs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static Length Parsecs<T>(this T value)
 #endif
             => Length.FromParsecs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromPicometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromPicometers(double)" />
         public static Length Picometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static Length Picometers<T>(this T value)
 #endif
             => Length.FromPicometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromPrinterPicas(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromPrinterPicas(double)" />
         public static Length PrinterPicas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static Length PrinterPicas<T>(this T value)
 #endif
             => Length.FromPrinterPicas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromPrinterPoints(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromPrinterPoints(double)" />
         public static Length PrinterPoints<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static Length PrinterPoints<T>(this T value)
 #endif
             => Length.FromPrinterPoints(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromShackles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromShackles(double)" />
         public static Length Shackles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -336,7 +336,7 @@ public static Length Shackles<T>(this T value)
 #endif
             => Length.FromShackles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromSolarRadiuses(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromSolarRadiuses(double)" />
         public static Length SolarRadiuses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -344,7 +344,7 @@ public static Length SolarRadiuses<T>(this T value)
 #endif
             => Length.FromSolarRadiuses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromTwips(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromTwips(double)" />
         public static Length Twips<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -352,7 +352,7 @@ public static Length Twips<T>(this T value)
 #endif
             => Length.FromTwips(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromUsSurveyFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromUsSurveyFeet(double)" />
         public static Length UsSurveyFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -360,7 +360,7 @@ public static Length UsSurveyFeet<T>(this T value)
 #endif
             => Length.FromUsSurveyFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Length.FromYards(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Length.FromYards(double)" />
         public static Length Yards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
index a07a57052c..3d1c71a5c6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLevelExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLevel
     /// </summary>
     public static class NumberToLevelExtensions
     {
-        /// <inheritdoc cref="Level.FromDecibels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Level.FromDecibels(double)" />
         public static Level Decibels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Level Decibels<T>(this T value)
 #endif
             => Level.FromDecibels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Level.FromNepers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Level.FromNepers(double)" />
         public static Level Nepers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
index 10064dcb4c..b86df0fd24 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLinearDensity
     /// </summary>
     public static class NumberToLinearDensityExtensions
     {
-        /// <inheritdoc cref="LinearDensity.FromGramsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromGramsPerCentimeter(double)" />
         public static LinearDensity GramsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static LinearDensity GramsPerCentimeter<T>(this T value)
 #endif
             => LinearDensity.FromGramsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromGramsPerMeter(double)" />
         public static LinearDensity GramsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static LinearDensity GramsPerMeter<T>(this T value)
 #endif
             => LinearDensity.FromGramsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromGramsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromGramsPerMillimeter(double)" />
         public static LinearDensity GramsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static LinearDensity GramsPerMillimeter<T>(this T value)
 #endif
             => LinearDensity.FromGramsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromKilogramsPerCentimeter(double)" />
         public static LinearDensity KilogramsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static LinearDensity KilogramsPerCentimeter<T>(this T value)
 #endif
             => LinearDensity.FromKilogramsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMeter(double)" />
         public static LinearDensity KilogramsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static LinearDensity KilogramsPerMeter<T>(this T value)
 #endif
             => LinearDensity.FromKilogramsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromKilogramsPerMillimeter(double)" />
         public static LinearDensity KilogramsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static LinearDensity KilogramsPerMillimeter<T>(this T value)
 #endif
             => LinearDensity.FromKilogramsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerCentimeter(double)" />
         public static LinearDensity MicrogramsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static LinearDensity MicrogramsPerCentimeter<T>(this T value)
 #endif
             => LinearDensity.FromMicrogramsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMeter(double)" />
         public static LinearDensity MicrogramsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static LinearDensity MicrogramsPerMeter<T>(this T value)
 #endif
             => LinearDensity.FromMicrogramsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromMicrogramsPerMillimeter(double)" />
         public static LinearDensity MicrogramsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static LinearDensity MicrogramsPerMillimeter<T>(this T value)
 #endif
             => LinearDensity.FromMicrogramsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromMilligramsPerCentimeter(double)" />
         public static LinearDensity MilligramsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static LinearDensity MilligramsPerCentimeter<T>(this T value)
 #endif
             => LinearDensity.FromMilligramsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMeter(double)" />
         public static LinearDensity MilligramsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static LinearDensity MilligramsPerMeter<T>(this T value)
 #endif
             => LinearDensity.FromMilligramsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromMilligramsPerMillimeter(double)" />
         public static LinearDensity MilligramsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static LinearDensity MilligramsPerMillimeter<T>(this T value)
 #endif
             => LinearDensity.FromMilligramsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromPoundsPerFoot(double)" />
         public static LinearDensity PoundsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static LinearDensity PoundsPerFoot<T>(this T value)
 #endif
             => LinearDensity.FromPoundsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearDensity.FromPoundsPerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearDensity.FromPoundsPerInch(double)" />
         public static LinearDensity PoundsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
index a41f134023..053dfdd3bb 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLinearPowerDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLinearPowerDensity
     /// </summary>
     public static class NumberToLinearPowerDensityExtensions
     {
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerCentimeter(double)" />
         public static LinearPowerDensity GigawattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static LinearPowerDensity GigawattsPerCentimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromGigawattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerFoot(double)" />
         public static LinearPowerDensity GigawattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static LinearPowerDensity GigawattsPerFoot<T>(this T value)
 #endif
             => LinearPowerDensity.FromGigawattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerInch(double)" />
         public static LinearPowerDensity GigawattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static LinearPowerDensity GigawattsPerInch<T>(this T value)
 #endif
             => LinearPowerDensity.FromGigawattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMeter(double)" />
         public static LinearPowerDensity GigawattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static LinearPowerDensity GigawattsPerMeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromGigawattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromGigawattsPerMillimeter(double)" />
         public static LinearPowerDensity GigawattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static LinearPowerDensity GigawattsPerMillimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromGigawattsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerCentimeter(double)" />
         public static LinearPowerDensity KilowattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static LinearPowerDensity KilowattsPerCentimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromKilowattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerFoot(double)" />
         public static LinearPowerDensity KilowattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static LinearPowerDensity KilowattsPerFoot<T>(this T value)
 #endif
             => LinearPowerDensity.FromKilowattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerInch(double)" />
         public static LinearPowerDensity KilowattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static LinearPowerDensity KilowattsPerInch<T>(this T value)
 #endif
             => LinearPowerDensity.FromKilowattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMeter(double)" />
         public static LinearPowerDensity KilowattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static LinearPowerDensity KilowattsPerMeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromKilowattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromKilowattsPerMillimeter(double)" />
         public static LinearPowerDensity KilowattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static LinearPowerDensity KilowattsPerMillimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromKilowattsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerCentimeter(double)" />
         public static LinearPowerDensity MegawattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static LinearPowerDensity MegawattsPerCentimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromMegawattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerFoot(double)" />
         public static LinearPowerDensity MegawattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static LinearPowerDensity MegawattsPerFoot<T>(this T value)
 #endif
             => LinearPowerDensity.FromMegawattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerInch(double)" />
         public static LinearPowerDensity MegawattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static LinearPowerDensity MegawattsPerInch<T>(this T value)
 #endif
             => LinearPowerDensity.FromMegawattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMeter(double)" />
         public static LinearPowerDensity MegawattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static LinearPowerDensity MegawattsPerMeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromMegawattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMegawattsPerMillimeter(double)" />
         public static LinearPowerDensity MegawattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static LinearPowerDensity MegawattsPerMillimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromMegawattsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerCentimeter(double)" />
         public static LinearPowerDensity MilliwattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static LinearPowerDensity MilliwattsPerCentimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromMilliwattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerFoot(double)" />
         public static LinearPowerDensity MilliwattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static LinearPowerDensity MilliwattsPerFoot<T>(this T value)
 #endif
             => LinearPowerDensity.FromMilliwattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerInch(double)" />
         public static LinearPowerDensity MilliwattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static LinearPowerDensity MilliwattsPerInch<T>(this T value)
 #endif
             => LinearPowerDensity.FromMilliwattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMeter(double)" />
         public static LinearPowerDensity MilliwattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static LinearPowerDensity MilliwattsPerMeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromMilliwattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromMilliwattsPerMillimeter(double)" />
         public static LinearPowerDensity MilliwattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static LinearPowerDensity MilliwattsPerMillimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromMilliwattsPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerCentimeter(double)" />
         public static LinearPowerDensity WattsPerCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static LinearPowerDensity WattsPerCentimeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromWattsPerCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerFoot(double)" />
         public static LinearPowerDensity WattsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static LinearPowerDensity WattsPerFoot<T>(this T value)
 #endif
             => LinearPowerDensity.FromWattsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerInch(double)" />
         public static LinearPowerDensity WattsPerInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static LinearPowerDensity WattsPerInch<T>(this T value)
 #endif
             => LinearPowerDensity.FromWattsPerInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMeter(double)" />
         public static LinearPowerDensity WattsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static LinearPowerDensity WattsPerMeter<T>(this T value)
 #endif
             => LinearPowerDensity.FromWattsPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LinearPowerDensity.FromWattsPerMillimeter(double)" />
         public static LinearPowerDensity WattsPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminanceExtensions.g.cs
index a76c6723f4..8a465149e9 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLuminance
     /// </summary>
     public static class NumberToLuminanceExtensions
     {
-        /// <inheritdoc cref="Luminance.FromCandelasPerSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromCandelasPerSquareFoot(double)" />
         public static Luminance CandelasPerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Luminance CandelasPerSquareFoot<T>(this T value)
 #endif
             => Luminance.FromCandelasPerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromCandelasPerSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromCandelasPerSquareInch(double)" />
         public static Luminance CandelasPerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Luminance CandelasPerSquareInch<T>(this T value)
 #endif
             => Luminance.FromCandelasPerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromCandelasPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromCandelasPerSquareMeter(double)" />
         public static Luminance CandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Luminance CandelasPerSquareMeter<T>(this T value)
 #endif
             => Luminance.FromCandelasPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromCenticandelasPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromCenticandelasPerSquareMeter(double)" />
         public static Luminance CenticandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Luminance CenticandelasPerSquareMeter<T>(this T value)
 #endif
             => Luminance.FromCenticandelasPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromDecicandelasPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromDecicandelasPerSquareMeter(double)" />
         public static Luminance DecicandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Luminance DecicandelasPerSquareMeter<T>(this T value)
 #endif
             => Luminance.FromDecicandelasPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromKilocandelasPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromKilocandelasPerSquareMeter(double)" />
         public static Luminance KilocandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Luminance KilocandelasPerSquareMeter<T>(this T value)
 #endif
             => Luminance.FromKilocandelasPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromMicrocandelasPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromMicrocandelasPerSquareMeter(double)" />
         public static Luminance MicrocandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Luminance MicrocandelasPerSquareMeter<T>(this T value)
 #endif
             => Luminance.FromMicrocandelasPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromMillicandelasPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromMillicandelasPerSquareMeter(double)" />
         public static Luminance MillicandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Luminance MillicandelasPerSquareMeter<T>(this T value)
 #endif
             => Luminance.FromMillicandelasPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromNanocandelasPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromNanocandelasPerSquareMeter(double)" />
         public static Luminance NanocandelasPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Luminance NanocandelasPerSquareMeter<T>(this T value)
 #endif
             => Luminance.FromNanocandelasPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminance.FromNits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminance.FromNits(double)" />
         public static Luminance Nits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
index 90f2813248..36b11e2995 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminosityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLuminosity
     /// </summary>
     public static class NumberToLuminosityExtensions
     {
-        /// <inheritdoc cref="Luminosity.FromDecawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromDecawatts(double)" />
         public static Luminosity Decawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Luminosity Decawatts<T>(this T value)
 #endif
             => Luminosity.FromDecawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromDeciwatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromDeciwatts(double)" />
         public static Luminosity Deciwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Luminosity Deciwatts<T>(this T value)
 #endif
             => Luminosity.FromDeciwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromFemtowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromFemtowatts(double)" />
         public static Luminosity Femtowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Luminosity Femtowatts<T>(this T value)
 #endif
             => Luminosity.FromFemtowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromGigawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromGigawatts(double)" />
         public static Luminosity Gigawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Luminosity Gigawatts<T>(this T value)
 #endif
             => Luminosity.FromGigawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromKilowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromKilowatts(double)" />
         public static Luminosity Kilowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Luminosity Kilowatts<T>(this T value)
 #endif
             => Luminosity.FromKilowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromMegawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromMegawatts(double)" />
         public static Luminosity Megawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Luminosity Megawatts<T>(this T value)
 #endif
             => Luminosity.FromMegawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromMicrowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromMicrowatts(double)" />
         public static Luminosity Microwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Luminosity Microwatts<T>(this T value)
 #endif
             => Luminosity.FromMicrowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromMilliwatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromMilliwatts(double)" />
         public static Luminosity Milliwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Luminosity Milliwatts<T>(this T value)
 #endif
             => Luminosity.FromMilliwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromNanowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromNanowatts(double)" />
         public static Luminosity Nanowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Luminosity Nanowatts<T>(this T value)
 #endif
             => Luminosity.FromNanowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromPetawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromPetawatts(double)" />
         public static Luminosity Petawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Luminosity Petawatts<T>(this T value)
 #endif
             => Luminosity.FromPetawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromPicowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromPicowatts(double)" />
         public static Luminosity Picowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Luminosity Picowatts<T>(this T value)
 #endif
             => Luminosity.FromPicowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromSolarLuminosities(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromSolarLuminosities(double)" />
         public static Luminosity SolarLuminosities<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Luminosity SolarLuminosities<T>(this T value)
 #endif
             => Luminosity.FromSolarLuminosities(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromTerawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromTerawatts(double)" />
         public static Luminosity Terawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Luminosity Terawatts<T>(this T value)
 #endif
             => Luminosity.FromTerawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Luminosity.FromWatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Luminosity.FromWatts(double)" />
         public static Luminosity Watts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
index a4f7ea6ae4..dd13f7f308 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousFluxExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLuminousFlux
     /// </summary>
     public static class NumberToLuminousFluxExtensions
     {
-        /// <inheritdoc cref="LuminousFlux.FromLumens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LuminousFlux.FromLumens(double)" />
         public static LuminousFlux Lumens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
index 95d8ba6679..724e6f1f69 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToLuminousIntensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToLuminousIntensity
     /// </summary>
     public static class NumberToLuminousIntensityExtensions
     {
-        /// <inheritdoc cref="LuminousIntensity.FromCandela(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="LuminousIntensity.FromCandela(double)" />
         public static LuminousIntensity Candela<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
index ac4482003a..67043e22b6 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFieldExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMagneticField
     /// </summary>
     public static class NumberToMagneticFieldExtensions
     {
-        /// <inheritdoc cref="MagneticField.FromGausses(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MagneticField.FromGausses(double)" />
         public static MagneticField Gausses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MagneticField Gausses<T>(this T value)
 #endif
             => MagneticField.FromGausses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromMicroteslas(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MagneticField.FromMicroteslas(double)" />
         public static MagneticField Microteslas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MagneticField Microteslas<T>(this T value)
 #endif
             => MagneticField.FromMicroteslas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromMilligausses(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MagneticField.FromMilligausses(double)" />
         public static MagneticField Milligausses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static MagneticField Milligausses<T>(this T value)
 #endif
             => MagneticField.FromMilligausses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromMilliteslas(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MagneticField.FromMilliteslas(double)" />
         public static MagneticField Milliteslas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static MagneticField Milliteslas<T>(this T value)
 #endif
             => MagneticField.FromMilliteslas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromNanoteslas(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MagneticField.FromNanoteslas(double)" />
         public static MagneticField Nanoteslas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static MagneticField Nanoteslas<T>(this T value)
 #endif
             => MagneticField.FromNanoteslas(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MagneticField.FromTeslas(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MagneticField.FromTeslas(double)" />
         public static MagneticField Teslas<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
index 266b22cd19..2c6e19b2b2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagneticFluxExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMagneticFlux
     /// </summary>
     public static class NumberToMagneticFluxExtensions
     {
-        /// <inheritdoc cref="MagneticFlux.FromWebers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MagneticFlux.FromWebers(double)" />
         public static MagneticFlux Webers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
index eed6e1c03c..114346ec96 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMagnetizationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMagnetization
     /// </summary>
     public static class NumberToMagnetizationExtensions
     {
-        /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Magnetization.FromAmperesPerMeter(double)" />
         public static Magnetization AmperesPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
index ea999dee49..6f8b73c46f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMassConcentration
     /// </summary>
     public static class NumberToMassConcentrationExtensions
     {
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerDeciliter(double)" />
         public static MassConcentration CentigramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MassConcentration CentigramsPerDeciliter<T>(this T value)
 #endif
             => MassConcentration.FromCentigramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerLiter(double)" />
         public static MassConcentration CentigramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MassConcentration CentigramsPerLiter<T>(this T value)
 #endif
             => MassConcentration.FromCentigramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMicroliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMicroliter(double)" />
         public static MassConcentration CentigramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static MassConcentration CentigramsPerMicroliter<T>(this T value)
 #endif
             => MassConcentration.FromCentigramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromCentigramsPerMilliliter(double)" />
         public static MassConcentration CentigramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static MassConcentration CentigramsPerMilliliter<T>(this T value)
 #endif
             => MassConcentration.FromCentigramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerDeciliter(double)" />
         public static MassConcentration DecigramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static MassConcentration DecigramsPerDeciliter<T>(this T value)
 #endif
             => MassConcentration.FromDecigramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerLiter(double)" />
         public static MassConcentration DecigramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static MassConcentration DecigramsPerLiter<T>(this T value)
 #endif
             => MassConcentration.FromDecigramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMicroliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMicroliter(double)" />
         public static MassConcentration DecigramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static MassConcentration DecigramsPerMicroliter<T>(this T value)
 #endif
             => MassConcentration.FromDecigramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromDecigramsPerMilliliter(double)" />
         public static MassConcentration DecigramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static MassConcentration DecigramsPerMilliliter<T>(this T value)
 #endif
             => MassConcentration.FromDecigramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicCentimeter(double)" />
         public static MassConcentration GramsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static MassConcentration GramsPerCubicCentimeter<T>(this T value)
 #endif
             => MassConcentration.FromGramsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMeter(double)" />
         public static MassConcentration GramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static MassConcentration GramsPerCubicMeter<T>(this T value)
 #endif
             => MassConcentration.FromGramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerCubicMillimeter(double)" />
         public static MassConcentration GramsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static MassConcentration GramsPerCubicMillimeter<T>(this T value)
 #endif
             => MassConcentration.FromGramsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerDeciliter(double)" />
         public static MassConcentration GramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static MassConcentration GramsPerDeciliter<T>(this T value)
 #endif
             => MassConcentration.FromGramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerLiter(double)" />
         public static MassConcentration GramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static MassConcentration GramsPerLiter<T>(this T value)
 #endif
             => MassConcentration.FromGramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerMicroliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerMicroliter(double)" />
         public static MassConcentration GramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static MassConcentration GramsPerMicroliter<T>(this T value)
 #endif
             => MassConcentration.FromGramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromGramsPerMilliliter(double)" />
         public static MassConcentration GramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static MassConcentration GramsPerMilliliter<T>(this T value)
 #endif
             => MassConcentration.FromGramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicCentimeter(double)" />
         public static MassConcentration KilogramsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static MassConcentration KilogramsPerCubicCentimeter<T>(this T value)
 #endif
             => MassConcentration.FromKilogramsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMeter(double)" />
         public static MassConcentration KilogramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static MassConcentration KilogramsPerCubicMeter<T>(this T value)
 #endif
             => MassConcentration.FromKilogramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerCubicMillimeter(double)" />
         public static MassConcentration KilogramsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static MassConcentration KilogramsPerCubicMillimeter<T>(this T value)
 #endif
             => MassConcentration.FromKilogramsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromKilogramsPerLiter(double)" />
         public static MassConcentration KilogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static MassConcentration KilogramsPerLiter<T>(this T value)
 #endif
             => MassConcentration.FromKilogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicFoot(double)" />
         public static MassConcentration KilopoundsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static MassConcentration KilopoundsPerCubicFoot<T>(this T value)
 #endif
             => MassConcentration.FromKilopoundsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromKilopoundsPerCubicInch(double)" />
         public static MassConcentration KilopoundsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static MassConcentration KilopoundsPerCubicInch<T>(this T value)
 #endif
             => MassConcentration.FromKilopoundsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerCubicMeter(double)" />
         public static MassConcentration MicrogramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static MassConcentration MicrogramsPerCubicMeter<T>(this T value)
 #endif
             => MassConcentration.FromMicrogramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerDeciliter(double)" />
         public static MassConcentration MicrogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static MassConcentration MicrogramsPerDeciliter<T>(this T value)
 #endif
             => MassConcentration.FromMicrogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerLiter(double)" />
         public static MassConcentration MicrogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static MassConcentration MicrogramsPerLiter<T>(this T value)
 #endif
             => MassConcentration.FromMicrogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMicroliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMicroliter(double)" />
         public static MassConcentration MicrogramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static MassConcentration MicrogramsPerMicroliter<T>(this T value)
 #endif
             => MassConcentration.FromMicrogramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMicrogramsPerMilliliter(double)" />
         public static MassConcentration MicrogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static MassConcentration MicrogramsPerMilliliter<T>(this T value)
 #endif
             => MassConcentration.FromMicrogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerCubicMeter(double)" />
         public static MassConcentration MilligramsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static MassConcentration MilligramsPerCubicMeter<T>(this T value)
 #endif
             => MassConcentration.FromMilligramsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerDeciliter(double)" />
         public static MassConcentration MilligramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static MassConcentration MilligramsPerDeciliter<T>(this T value)
 #endif
             => MassConcentration.FromMilligramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerLiter(double)" />
         public static MassConcentration MilligramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static MassConcentration MilligramsPerLiter<T>(this T value)
 #endif
             => MassConcentration.FromMilligramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMicroliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMicroliter(double)" />
         public static MassConcentration MilligramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static MassConcentration MilligramsPerMicroliter<T>(this T value)
 #endif
             => MassConcentration.FromMilligramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromMilligramsPerMilliliter(double)" />
         public static MassConcentration MilligramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static MassConcentration MilligramsPerMilliliter<T>(this T value)
 #endif
             => MassConcentration.FromMilligramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerDeciliter(double)" />
         public static MassConcentration NanogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static MassConcentration NanogramsPerDeciliter<T>(this T value)
 #endif
             => MassConcentration.FromNanogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerLiter(double)" />
         public static MassConcentration NanogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static MassConcentration NanogramsPerLiter<T>(this T value)
 #endif
             => MassConcentration.FromNanogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMicroliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMicroliter(double)" />
         public static MassConcentration NanogramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static MassConcentration NanogramsPerMicroliter<T>(this T value)
 #endif
             => MassConcentration.FromNanogramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromNanogramsPerMilliliter(double)" />
         public static MassConcentration NanogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static MassConcentration NanogramsPerMilliliter<T>(this T value)
 #endif
             => MassConcentration.FromNanogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromOuncesPerImperialGallon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromOuncesPerImperialGallon(double)" />
         public static MassConcentration OuncesPerImperialGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static MassConcentration OuncesPerImperialGallon<T>(this T value)
 #endif
             => MassConcentration.FromOuncesPerImperialGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromOuncesPerUSGallon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromOuncesPerUSGallon(double)" />
         public static MassConcentration OuncesPerUSGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static MassConcentration OuncesPerUSGallon<T>(this T value)
 #endif
             => MassConcentration.FromOuncesPerUSGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(double)" />
         public static MassConcentration PicogramsPerDeciliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -336,7 +336,7 @@ public static MassConcentration PicogramsPerDeciliter<T>(this T value)
 #endif
             => MassConcentration.FromPicogramsPerDeciliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerLiter(double)" />
         public static MassConcentration PicogramsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -344,7 +344,7 @@ public static MassConcentration PicogramsPerLiter<T>(this T value)
 #endif
             => MassConcentration.FromPicogramsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMicroliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMicroliter(double)" />
         public static MassConcentration PicogramsPerMicroliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -352,7 +352,7 @@ public static MassConcentration PicogramsPerMicroliter<T>(this T value)
 #endif
             => MassConcentration.FromPicogramsPerMicroliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromPicogramsPerMilliliter(double)" />
         public static MassConcentration PicogramsPerMilliliter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -360,7 +360,7 @@ public static MassConcentration PicogramsPerMilliliter<T>(this T value)
 #endif
             => MassConcentration.FromPicogramsPerMilliliter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicFoot(double)" />
         public static MassConcentration PoundsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -368,7 +368,7 @@ public static MassConcentration PoundsPerCubicFoot<T>(this T value)
 #endif
             => MassConcentration.FromPoundsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerCubicInch(double)" />
         public static MassConcentration PoundsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -376,7 +376,7 @@ public static MassConcentration PoundsPerCubicInch<T>(this T value)
 #endif
             => MassConcentration.FromPoundsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerImperialGallon(double)" />
         public static MassConcentration PoundsPerImperialGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -384,7 +384,7 @@ public static MassConcentration PoundsPerImperialGallon<T>(this T value)
 #endif
             => MassConcentration.FromPoundsPerImperialGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromPoundsPerUSGallon(double)" />
         public static MassConcentration PoundsPerUSGallon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -392,7 +392,7 @@ public static MassConcentration PoundsPerUSGallon<T>(this T value)
 #endif
             => MassConcentration.FromPoundsPerUSGallon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromSlugsPerCubicFoot(double)" />
         public static MassConcentration SlugsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -400,7 +400,7 @@ public static MassConcentration SlugsPerCubicFoot<T>(this T value)
 #endif
             => MassConcentration.FromSlugsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicCentimeter(double)" />
         public static MassConcentration TonnesPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -408,7 +408,7 @@ public static MassConcentration TonnesPerCubicCentimeter<T>(this T value)
 #endif
             => MassConcentration.FromTonnesPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMeter(double)" />
         public static MassConcentration TonnesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -416,7 +416,7 @@ public static MassConcentration TonnesPerCubicMeter<T>(this T value)
 #endif
             => MassConcentration.FromTonnesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassConcentration.FromTonnesPerCubicMillimeter(double)" />
         public static MassConcentration TonnesPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
index ebad988d59..f170ad547f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMass
     /// </summary>
     public static class NumberToMassExtensions
     {
-        /// <inheritdoc cref="Mass.FromCentigrams(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromCentigrams(double)" />
         public static Mass Centigrams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Mass Centigrams<T>(this T value)
 #endif
             => Mass.FromCentigrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromDecagrams(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromDecagrams(double)" />
         public static Mass Decagrams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Mass Decagrams<T>(this T value)
 #endif
             => Mass.FromDecagrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromDecigrams(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromDecigrams(double)" />
         public static Mass Decigrams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Mass Decigrams<T>(this T value)
 #endif
             => Mass.FromDecigrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromEarthMasses(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromEarthMasses(double)" />
         public static Mass EarthMasses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Mass EarthMasses<T>(this T value)
 #endif
             => Mass.FromEarthMasses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromFemtograms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromFemtograms(double)" />
         public static Mass Femtograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Mass Femtograms<T>(this T value)
 #endif
             => Mass.FromFemtograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromGrains(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromGrains(double)" />
         public static Mass Grains<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Mass Grains<T>(this T value)
 #endif
             => Mass.FromGrains(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromGrams(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromGrams(double)" />
         public static Mass Grams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Mass Grams<T>(this T value)
 #endif
             => Mass.FromGrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromHectograms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromHectograms(double)" />
         public static Mass Hectograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Mass Hectograms<T>(this T value)
 #endif
             => Mass.FromHectograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromKilograms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromKilograms(double)" />
         public static Mass Kilograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Mass Kilograms<T>(this T value)
 #endif
             => Mass.FromKilograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromKilopounds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromKilopounds(double)" />
         public static Mass Kilopounds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Mass Kilopounds<T>(this T value)
 #endif
             => Mass.FromKilopounds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromKilotonnes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromKilotonnes(double)" />
         public static Mass Kilotonnes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Mass Kilotonnes<T>(this T value)
 #endif
             => Mass.FromKilotonnes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromLongHundredweight(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromLongHundredweight(double)" />
         public static Mass LongHundredweight<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Mass LongHundredweight<T>(this T value)
 #endif
             => Mass.FromLongHundredweight(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromLongTons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromLongTons(double)" />
         public static Mass LongTons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Mass LongTons<T>(this T value)
 #endif
             => Mass.FromLongTons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromMegapounds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromMegapounds(double)" />
         public static Mass Megapounds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Mass Megapounds<T>(this T value)
 #endif
             => Mass.FromMegapounds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromMegatonnes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromMegatonnes(double)" />
         public static Mass Megatonnes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Mass Megatonnes<T>(this T value)
 #endif
             => Mass.FromMegatonnes(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromMicrograms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromMicrograms(double)" />
         public static Mass Micrograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Mass Micrograms<T>(this T value)
 #endif
             => Mass.FromMicrograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromMilligrams(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromMilligrams(double)" />
         public static Mass Milligrams<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Mass Milligrams<T>(this T value)
 #endif
             => Mass.FromMilligrams(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromNanograms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromNanograms(double)" />
         public static Mass Nanograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Mass Nanograms<T>(this T value)
 #endif
             => Mass.FromNanograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromOunces(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromOunces(double)" />
         public static Mass Ounces<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Mass Ounces<T>(this T value)
 #endif
             => Mass.FromOunces(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromPicograms(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromPicograms(double)" />
         public static Mass Picograms<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Mass Picograms<T>(this T value)
 #endif
             => Mass.FromPicograms(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromPounds(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromPounds(double)" />
         public static Mass Pounds<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Mass Pounds<T>(this T value)
 #endif
             => Mass.FromPounds(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromShortHundredweight(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromShortHundredweight(double)" />
         public static Mass ShortHundredweight<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Mass ShortHundredweight<T>(this T value)
 #endif
             => Mass.FromShortHundredweight(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromShortTons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromShortTons(double)" />
         public static Mass ShortTons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Mass ShortTons<T>(this T value)
 #endif
             => Mass.FromShortTons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromSlugs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromSlugs(double)" />
         public static Mass Slugs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Mass Slugs<T>(this T value)
 #endif
             => Mass.FromSlugs(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromSolarMasses(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromSolarMasses(double)" />
         public static Mass SolarMasses<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Mass SolarMasses<T>(this T value)
 #endif
             => Mass.FromSolarMasses(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromStone(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromStone(double)" />
         public static Mass Stone<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static Mass Stone<T>(this T value)
 #endif
             => Mass.FromStone(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Mass.FromTonnes(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Mass.FromTonnes(double)" />
         public static Mass Tonnes<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
index e7678f0598..3f75371a85 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFlowExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMassFlow
     /// </summary>
     public static class NumberToMassFlowExtensions
     {
-        /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromCentigramsPerDay(double)" />
         public static MassFlow CentigramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MassFlow CentigramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromCentigramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromCentigramsPerSecond(double)" />
         public static MassFlow CentigramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MassFlow CentigramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromCentigramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromDecagramsPerDay(double)" />
         public static MassFlow DecagramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static MassFlow DecagramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromDecagramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromDecagramsPerSecond(double)" />
         public static MassFlow DecagramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static MassFlow DecagramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromDecagramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromDecigramsPerDay(double)" />
         public static MassFlow DecigramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static MassFlow DecigramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromDecigramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromDecigramsPerSecond(double)" />
         public static MassFlow DecigramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static MassFlow DecigramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromDecigramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromGramsPerDay(double)" />
         public static MassFlow GramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static MassFlow GramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromGramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromGramsPerHour(double)" />
         public static MassFlow GramsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static MassFlow GramsPerHour<T>(this T value)
 #endif
             => MassFlow.FromGramsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromGramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromGramsPerSecond(double)" />
         public static MassFlow GramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static MassFlow GramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromGramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromHectogramsPerDay(double)" />
         public static MassFlow HectogramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static MassFlow HectogramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromHectogramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromHectogramsPerSecond(double)" />
         public static MassFlow HectogramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static MassFlow HectogramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromHectogramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerDay(double)" />
         public static MassFlow KilogramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static MassFlow KilogramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromKilogramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerHour(double)" />
         public static MassFlow KilogramsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static MassFlow KilogramsPerHour<T>(this T value)
 #endif
             => MassFlow.FromKilogramsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerMinute(double)" />
         public static MassFlow KilogramsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static MassFlow KilogramsPerMinute<T>(this T value)
 #endif
             => MassFlow.FromKilogramsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromKilogramsPerSecond(double)" />
         public static MassFlow KilogramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static MassFlow KilogramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromKilogramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMegagramsPerDay(double)" />
         public static MassFlow MegagramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static MassFlow MegagramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromMegagramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerDay(double)" />
         public static MassFlow MegapoundsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static MassFlow MegapoundsPerDay<T>(this T value)
 #endif
             => MassFlow.FromMegapoundsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerHour(double)" />
         public static MassFlow MegapoundsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static MassFlow MegapoundsPerHour<T>(this T value)
 #endif
             => MassFlow.FromMegapoundsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerMinute(double)" />
         public static MassFlow MegapoundsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static MassFlow MegapoundsPerMinute<T>(this T value)
 #endif
             => MassFlow.FromMegapoundsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMegapoundsPerSecond(double)" />
         public static MassFlow MegapoundsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static MassFlow MegapoundsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromMegapoundsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMicrogramsPerDay(double)" />
         public static MassFlow MicrogramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static MassFlow MicrogramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromMicrogramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMicrogramsPerSecond(double)" />
         public static MassFlow MicrogramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static MassFlow MicrogramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromMicrogramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMilligramsPerDay(double)" />
         public static MassFlow MilligramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static MassFlow MilligramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromMilligramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromMilligramsPerSecond(double)" />
         public static MassFlow MilligramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static MassFlow MilligramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromMilligramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromNanogramsPerDay(double)" />
         public static MassFlow NanogramsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static MassFlow NanogramsPerDay<T>(this T value)
 #endif
             => MassFlow.FromNanogramsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromNanogramsPerSecond(double)" />
         public static MassFlow NanogramsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static MassFlow NanogramsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromNanogramsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromPoundsPerDay(double)" />
         public static MassFlow PoundsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static MassFlow PoundsPerDay<T>(this T value)
 #endif
             => MassFlow.FromPoundsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromPoundsPerHour(double)" />
         public static MassFlow PoundsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static MassFlow PoundsPerHour<T>(this T value)
 #endif
             => MassFlow.FromPoundsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromPoundsPerMinute(double)" />
         public static MassFlow PoundsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static MassFlow PoundsPerMinute<T>(this T value)
 #endif
             => MassFlow.FromPoundsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromPoundsPerSecond(double)" />
         public static MassFlow PoundsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static MassFlow PoundsPerSecond<T>(this T value)
 #endif
             => MassFlow.FromPoundsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromShortTonsPerHour(double)" />
         public static MassFlow ShortTonsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static MassFlow ShortTonsPerHour<T>(this T value)
 #endif
             => MassFlow.FromShortTonsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromTonnesPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromTonnesPerDay(double)" />
         public static MassFlow TonnesPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static MassFlow TonnesPerDay<T>(this T value)
 #endif
             => MassFlow.FromTonnesPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlow.FromTonnesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlow.FromTonnesPerHour(double)" />
         public static MassFlow TonnesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
index bde8e8d1d9..2e8c63df81 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFluxExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMassFlux
     /// </summary>
     public static class NumberToMassFluxExtensions
     {
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareCentimeter(double)" />
         public static MassFlux GramsPerHourPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MassFlux GramsPerHourPerSquareCentimeter<T>(this T value)
 #endif
             => MassFlux.FromGramsPerHourPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMeter(double)" />
         public static MassFlux GramsPerHourPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MassFlux GramsPerHourPerSquareMeter<T>(this T value)
 #endif
             => MassFlux.FromGramsPerHourPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerHourPerSquareMillimeter(double)" />
         public static MassFlux GramsPerHourPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static MassFlux GramsPerHourPerSquareMillimeter<T>(this T value)
 #endif
             => MassFlux.FromGramsPerHourPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareCentimeter(double)" />
         public static MassFlux GramsPerSecondPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static MassFlux GramsPerSecondPerSquareCentimeter<T>(this T value)
 #endif
             => MassFlux.FromGramsPerSecondPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMeter(double)" />
         public static MassFlux GramsPerSecondPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static MassFlux GramsPerSecondPerSquareMeter<T>(this T value)
 #endif
             => MassFlux.FromGramsPerSecondPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromGramsPerSecondPerSquareMillimeter(double)" />
         public static MassFlux GramsPerSecondPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static MassFlux GramsPerSecondPerSquareMillimeter<T>(this T value)
 #endif
             => MassFlux.FromGramsPerSecondPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareCentimeter(double)" />
         public static MassFlux KilogramsPerHourPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static MassFlux KilogramsPerHourPerSquareCentimeter<T>(this T value)
 #endif
             => MassFlux.FromKilogramsPerHourPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMeter(double)" />
         public static MassFlux KilogramsPerHourPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static MassFlux KilogramsPerHourPerSquareMeter<T>(this T value)
 #endif
             => MassFlux.FromKilogramsPerHourPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerHourPerSquareMillimeter(double)" />
         public static MassFlux KilogramsPerHourPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static MassFlux KilogramsPerHourPerSquareMillimeter<T>(this T value)
 #endif
             => MassFlux.FromKilogramsPerHourPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareCentimeter(double)" />
         public static MassFlux KilogramsPerSecondPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static MassFlux KilogramsPerSecondPerSquareCentimeter<T>(this T value)
 #endif
             => MassFlux.FromKilogramsPerSecondPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMeter(double)" />
         public static MassFlux KilogramsPerSecondPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static MassFlux KilogramsPerSecondPerSquareMeter<T>(this T value)
 #endif
             => MassFlux.FromKilogramsPerSecondPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFlux.FromKilogramsPerSecondPerSquareMillimeter(double)" />
         public static MassFlux KilogramsPerSecondPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
index 2e63ff2006..6f499b2090 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassFractionExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMassFraction
     /// </summary>
     public static class NumberToMassFractionExtensions
     {
-        /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromCentigramsPerGram(double)" />
         public static MassFraction CentigramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MassFraction CentigramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromCentigramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromCentigramsPerKilogram(double)" />
         public static MassFraction CentigramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MassFraction CentigramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromCentigramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromDecagramsPerGram(double)" />
         public static MassFraction DecagramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static MassFraction DecagramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromDecagramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromDecagramsPerKilogram(double)" />
         public static MassFraction DecagramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static MassFraction DecagramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromDecagramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromDecigramsPerGram(double)" />
         public static MassFraction DecigramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static MassFraction DecigramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromDecigramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromDecigramsPerKilogram(double)" />
         public static MassFraction DecigramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static MassFraction DecigramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromDecigramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromDecimalFractions(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromDecimalFractions(double)" />
         public static MassFraction DecimalFractions<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static MassFraction DecimalFractions<T>(this T value)
 #endif
             => MassFraction.FromDecimalFractions(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromGramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromGramsPerGram(double)" />
         public static MassFraction GramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static MassFraction GramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromGramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromGramsPerKilogram(double)" />
         public static MassFraction GramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static MassFraction GramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromGramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromHectogramsPerGram(double)" />
         public static MassFraction HectogramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static MassFraction HectogramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromHectogramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromHectogramsPerKilogram(double)" />
         public static MassFraction HectogramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static MassFraction HectogramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromHectogramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromKilogramsPerGram(double)" />
         public static MassFraction KilogramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static MassFraction KilogramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromKilogramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromKilogramsPerKilogram(double)" />
         public static MassFraction KilogramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static MassFraction KilogramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromKilogramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromMicrogramsPerGram(double)" />
         public static MassFraction MicrogramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static MassFraction MicrogramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromMicrogramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromMicrogramsPerKilogram(double)" />
         public static MassFraction MicrogramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static MassFraction MicrogramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromMicrogramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromMilligramsPerGram(double)" />
         public static MassFraction MilligramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static MassFraction MilligramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromMilligramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromMilligramsPerKilogram(double)" />
         public static MassFraction MilligramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static MassFraction MilligramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromMilligramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromNanogramsPerGram(double)" />
         public static MassFraction NanogramsPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static MassFraction NanogramsPerGram<T>(this T value)
 #endif
             => MassFraction.FromNanogramsPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromNanogramsPerKilogram(double)" />
         public static MassFraction NanogramsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static MassFraction NanogramsPerKilogram<T>(this T value)
 #endif
             => MassFraction.FromNanogramsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerBillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromPartsPerBillion(double)" />
         public static MassFraction PartsPerBillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static MassFraction PartsPerBillion<T>(this T value)
 #endif
             => MassFraction.FromPartsPerBillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerMillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromPartsPerMillion(double)" />
         public static MassFraction PartsPerMillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static MassFraction PartsPerMillion<T>(this T value)
 #endif
             => MassFraction.FromPartsPerMillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerThousand(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromPartsPerThousand(double)" />
         public static MassFraction PartsPerThousand<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static MassFraction PartsPerThousand<T>(this T value)
 #endif
             => MassFraction.FromPartsPerThousand(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromPartsPerTrillion(double)" />
         public static MassFraction PartsPerTrillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static MassFraction PartsPerTrillion<T>(this T value)
 #endif
             => MassFraction.FromPartsPerTrillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassFraction.FromPercent(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassFraction.FromPercent(double)" />
         public static MassFraction Percent<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
index 9f31d01532..1aae922769 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassMomentOfInertiaExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMassMomentOfInertia
     /// </summary>
     public static class NumberToMassMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareCentimeters(double)" />
         public static MassMomentOfInertia GramSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MassMomentOfInertia GramSquareCentimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromGramSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareDecimeters(double)" />
         public static MassMomentOfInertia GramSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MassMomentOfInertia GramSquareDecimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromGramSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMeters(double)" />
         public static MassMomentOfInertia GramSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static MassMomentOfInertia GramSquareMeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromGramSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromGramSquareMillimeters(double)" />
         public static MassMomentOfInertia GramSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static MassMomentOfInertia GramSquareMillimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromGramSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareCentimeters(double)" />
         public static MassMomentOfInertia KilogramSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static MassMomentOfInertia KilogramSquareCentimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromKilogramSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareDecimeters(double)" />
         public static MassMomentOfInertia KilogramSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static MassMomentOfInertia KilogramSquareDecimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromKilogramSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMeters(double)" />
         public static MassMomentOfInertia KilogramSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static MassMomentOfInertia KilogramSquareMeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromKilogramSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilogramSquareMillimeters(double)" />
         public static MassMomentOfInertia KilogramSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static MassMomentOfInertia KilogramSquareMillimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromKilogramSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareCentimeters(double)" />
         public static MassMomentOfInertia KilotonneSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static MassMomentOfInertia KilotonneSquareCentimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromKilotonneSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareDecimeters(double)" />
         public static MassMomentOfInertia KilotonneSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static MassMomentOfInertia KilotonneSquareDecimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromKilotonneSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMeters(double)" />
         public static MassMomentOfInertia KilotonneSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static MassMomentOfInertia KilotonneSquareMeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromKilotonneSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMilimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromKilotonneSquareMilimeters(double)" />
         public static MassMomentOfInertia KilotonneSquareMilimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static MassMomentOfInertia KilotonneSquareMilimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromKilotonneSquareMilimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareCentimeters(double)" />
         public static MassMomentOfInertia MegatonneSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static MassMomentOfInertia MegatonneSquareCentimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromMegatonneSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareDecimeters(double)" />
         public static MassMomentOfInertia MegatonneSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static MassMomentOfInertia MegatonneSquareDecimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromMegatonneSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMeters(double)" />
         public static MassMomentOfInertia MegatonneSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static MassMomentOfInertia MegatonneSquareMeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromMegatonneSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMilimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMegatonneSquareMilimeters(double)" />
         public static MassMomentOfInertia MegatonneSquareMilimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static MassMomentOfInertia MegatonneSquareMilimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromMegatonneSquareMilimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareCentimeters(double)" />
         public static MassMomentOfInertia MilligramSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static MassMomentOfInertia MilligramSquareCentimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromMilligramSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareDecimeters(double)" />
         public static MassMomentOfInertia MilligramSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static MassMomentOfInertia MilligramSquareDecimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromMilligramSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMeters(double)" />
         public static MassMomentOfInertia MilligramSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static MassMomentOfInertia MilligramSquareMeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromMilligramSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromMilligramSquareMillimeters(double)" />
         public static MassMomentOfInertia MilligramSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static MassMomentOfInertia MilligramSquareMillimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromMilligramSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareFeet(double)" />
         public static MassMomentOfInertia PoundSquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static MassMomentOfInertia PoundSquareFeet<T>(this T value)
 #endif
             => MassMomentOfInertia.FromPoundSquareFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromPoundSquareInches(double)" />
         public static MassMomentOfInertia PoundSquareInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static MassMomentOfInertia PoundSquareInches<T>(this T value)
 #endif
             => MassMomentOfInertia.FromPoundSquareInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareFeet(double)" />
         public static MassMomentOfInertia SlugSquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static MassMomentOfInertia SlugSquareFeet<T>(this T value)
 #endif
             => MassMomentOfInertia.FromSlugSquareFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromSlugSquareInches(double)" />
         public static MassMomentOfInertia SlugSquareInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static MassMomentOfInertia SlugSquareInches<T>(this T value)
 #endif
             => MassMomentOfInertia.FromSlugSquareInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareCentimeters(double)" />
         public static MassMomentOfInertia TonneSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static MassMomentOfInertia TonneSquareCentimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromTonneSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareDecimeters(double)" />
         public static MassMomentOfInertia TonneSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static MassMomentOfInertia TonneSquareDecimeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromTonneSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMeters(double)" />
         public static MassMomentOfInertia TonneSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static MassMomentOfInertia TonneSquareMeters<T>(this T value)
 #endif
             => MassMomentOfInertia.FromTonneSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMilimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MassMomentOfInertia.FromTonneSquareMilimeters(double)" />
         public static MassMomentOfInertia TonneSquareMilimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolalityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolalityExtensions.g.cs
index 5082f28861..ce9fd27d4a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolalityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolalityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMolality
     /// </summary>
     public static class NumberToMolalityExtensions
     {
-        /// <inheritdoc cref="Molality.FromMolesPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molality.FromMolesPerGram(double)" />
         public static Molality MolesPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Molality MolesPerGram<T>(this T value)
 #endif
             => Molality.FromMolesPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molality.FromMolesPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molality.FromMolesPerKilogram(double)" />
         public static Molality MolesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
index fca5e9f60a..caf2e58733 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEnergyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMolarEnergy
     /// </summary>
     public static class NumberToMolarEnergyExtensions
     {
-        /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarEnergy.FromJoulesPerMole(double)" />
         public static MolarEnergy JoulesPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MolarEnergy JoulesPerMole<T>(this T value)
 #endif
             => MolarEnergy.FromJoulesPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarEnergy.FromKilojoulesPerMole(double)" />
         public static MolarEnergy KilojoulesPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MolarEnergy KilojoulesPerMole<T>(this T value)
 #endif
             => MolarEnergy.FromKilojoulesPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarEnergy.FromMegajoulesPerMole(double)" />
         public static MolarEnergy MegajoulesPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
index 19d7ed5549..27264a55b3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarEntropyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMolarEntropy
     /// </summary>
     public static class NumberToMolarEntropyExtensions
     {
-        /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarEntropy.FromJoulesPerMoleKelvin(double)" />
         public static MolarEntropy JoulesPerMoleKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MolarEntropy JoulesPerMoleKelvin<T>(this T value)
 #endif
             => MolarEntropy.FromJoulesPerMoleKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarEntropy.FromKilojoulesPerMoleKelvin(double)" />
         public static MolarEntropy KilojoulesPerMoleKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MolarEntropy KilojoulesPerMoleKelvin<T>(this T value)
 #endif
             => MolarEntropy.FromKilojoulesPerMoleKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarEntropy.FromMegajoulesPerMoleKelvin(double)" />
         public static MolarEntropy MegajoulesPerMoleKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarFlowExtensions.g.cs
index ec94516d59..0b2ab19d42 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarFlowExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMolarFlow
     /// </summary>
     public static class NumberToMolarFlowExtensions
     {
-        /// <inheritdoc cref="MolarFlow.FromKilomolesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromKilomolesPerHour(double)" />
         public static MolarFlow KilomolesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MolarFlow KilomolesPerHour<T>(this T value)
 #endif
             => MolarFlow.FromKilomolesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarFlow.FromKilomolesPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromKilomolesPerMinute(double)" />
         public static MolarFlow KilomolesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MolarFlow KilomolesPerMinute<T>(this T value)
 #endif
             => MolarFlow.FromKilomolesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarFlow.FromKilomolesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromKilomolesPerSecond(double)" />
         public static MolarFlow KilomolesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static MolarFlow KilomolesPerSecond<T>(this T value)
 #endif
             => MolarFlow.FromKilomolesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarFlow.FromMolesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromMolesPerHour(double)" />
         public static MolarFlow MolesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static MolarFlow MolesPerHour<T>(this T value)
 #endif
             => MolarFlow.FromMolesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarFlow.FromMolesPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromMolesPerMinute(double)" />
         public static MolarFlow MolesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static MolarFlow MolesPerMinute<T>(this T value)
 #endif
             => MolarFlow.FromMolesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarFlow.FromMolesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromMolesPerSecond(double)" />
         public static MolarFlow MolesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static MolarFlow MolesPerSecond<T>(this T value)
 #endif
             => MolarFlow.FromMolesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerHour(double)" />
         public static MolarFlow PoundMolesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static MolarFlow PoundMolesPerHour<T>(this T value)
 #endif
             => MolarFlow.FromPoundMolesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerMinute(double)" />
         public static MolarFlow PoundMolesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static MolarFlow PoundMolesPerMinute<T>(this T value)
 #endif
             => MolarFlow.FromPoundMolesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarFlow.FromPoundMolesPerSecond(double)" />
         public static MolarFlow PoundMolesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
index 118a9eb220..42daf96a91 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarMassExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMolarMass
     /// </summary>
     public static class NumberToMolarMassExtensions
     {
-        /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromCentigramsPerMole(double)" />
         public static MolarMass CentigramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static MolarMass CentigramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromCentigramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromDecagramsPerMole(double)" />
         public static MolarMass DecagramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static MolarMass DecagramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromDecagramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromDecigramsPerMole(double)" />
         public static MolarMass DecigramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static MolarMass DecigramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromDecigramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromGramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromGramsPerMole(double)" />
         public static MolarMass GramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static MolarMass GramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromGramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromHectogramsPerMole(double)" />
         public static MolarMass HectogramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static MolarMass HectogramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromHectogramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromKilogramsPerKilomole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromKilogramsPerKilomole(double)" />
         public static MolarMass KilogramsPerKilomole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static MolarMass KilogramsPerKilomole<T>(this T value)
 #endif
             => MolarMass.FromKilogramsPerKilomole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromKilogramsPerMole(double)" />
         public static MolarMass KilogramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static MolarMass KilogramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromKilogramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromKilopoundsPerMole(double)" />
         public static MolarMass KilopoundsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static MolarMass KilopoundsPerMole<T>(this T value)
 #endif
             => MolarMass.FromKilopoundsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromMegapoundsPerMole(double)" />
         public static MolarMass MegapoundsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static MolarMass MegapoundsPerMole<T>(this T value)
 #endif
             => MolarMass.FromMegapoundsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromMicrogramsPerMole(double)" />
         public static MolarMass MicrogramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static MolarMass MicrogramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromMicrogramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromMilligramsPerMole(double)" />
         public static MolarMass MilligramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static MolarMass MilligramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromMilligramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromNanogramsPerMole(double)" />
         public static MolarMass NanogramsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static MolarMass NanogramsPerMole<T>(this T value)
 #endif
             => MolarMass.FromNanogramsPerMole(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="MolarMass.FromPoundsPerMole(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="MolarMass.FromPoundsPerMole(double)" />
         public static MolarMass PoundsPerMole<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
index 60ed5bf178..eb2f51f2bb 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMolarityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToMolarity
     /// </summary>
     public static class NumberToMolarityExtensions
     {
-        /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromCentimolesPerLiter(double)" />
         public static Molarity CentimolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Molarity CentimolesPerLiter<T>(this T value)
 #endif
             => Molarity.FromCentimolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromDecimolesPerLiter(double)" />
         public static Molarity DecimolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Molarity DecimolesPerLiter<T>(this T value)
 #endif
             => Molarity.FromDecimolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromFemtomolesPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromFemtomolesPerLiter(double)" />
         public static Molarity FemtomolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Molarity FemtomolesPerLiter<T>(this T value)
 #endif
             => Molarity.FromFemtomolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromKilomolesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromKilomolesPerCubicMeter(double)" />
         public static Molarity KilomolesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Molarity KilomolesPerCubicMeter<T>(this T value)
 #endif
             => Molarity.FromKilomolesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromMicromolesPerLiter(double)" />
         public static Molarity MicromolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Molarity MicromolesPerLiter<T>(this T value)
 #endif
             => Molarity.FromMicromolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromMillimolesPerLiter(double)" />
         public static Molarity MillimolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Molarity MillimolesPerLiter<T>(this T value)
 #endif
             => Molarity.FromMillimolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromMolesPerCubicMeter(double)" />
         public static Molarity MolesPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Molarity MolesPerCubicMeter<T>(this T value)
 #endif
             => Molarity.FromMolesPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromMolesPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromMolesPerLiter(double)" />
         public static Molarity MolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Molarity MolesPerLiter<T>(this T value)
 #endif
             => Molarity.FromMolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromNanomolesPerLiter(double)" />
         public static Molarity NanomolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Molarity NanomolesPerLiter<T>(this T value)
 #endif
             => Molarity.FromNanomolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromPicomolesPerLiter(double)" />
         public static Molarity PicomolesPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Molarity PicomolesPerLiter<T>(this T value)
 #endif
             => Molarity.FromPicomolesPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Molarity.FromPoundMolesPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Molarity.FromPoundMolesPerCubicFoot(double)" />
         public static Molarity PoundMolesPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
index 8ca254bcf0..c1c5f1b458 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermeabilityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToPermeability
     /// </summary>
     public static class NumberToPermeabilityExtensions
     {
-        /// <inheritdoc cref="Permeability.FromHenriesPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Permeability.FromHenriesPerMeter(double)" />
         public static Permeability HenriesPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
index a1165291c5..1c3b83a7b7 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPermittivityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToPermittivity
     /// </summary>
     public static class NumberToPermittivityExtensions
     {
-        /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Permittivity.FromFaradsPerMeter(double)" />
         public static Permittivity FaradsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
index 5ec99c071f..9198d7c7c3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPorousMediumPermeabilityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToPorousMediumPermeability
     /// </summary>
     public static class NumberToPorousMediumPermeabilityExtensions
     {
-        /// <inheritdoc cref="PorousMediumPermeability.FromDarcys(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromDarcys(double)" />
         public static PorousMediumPermeability Darcys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static PorousMediumPermeability Darcys<T>(this T value)
 #endif
             => PorousMediumPermeability.FromDarcys(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PorousMediumPermeability.FromMicrodarcys(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromMicrodarcys(double)" />
         public static PorousMediumPermeability Microdarcys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static PorousMediumPermeability Microdarcys<T>(this T value)
 #endif
             => PorousMediumPermeability.FromMicrodarcys(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PorousMediumPermeability.FromMillidarcys(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromMillidarcys(double)" />
         public static PorousMediumPermeability Millidarcys<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static PorousMediumPermeability Millidarcys<T>(this T value)
 #endif
             => PorousMediumPermeability.FromMillidarcys(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PorousMediumPermeability.FromSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromSquareCentimeters(double)" />
         public static PorousMediumPermeability SquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static PorousMediumPermeability SquareCentimeters<T>(this T value)
 #endif
             => PorousMediumPermeability.FromSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PorousMediumPermeability.FromSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PorousMediumPermeability.FromSquareMeters(double)" />
         public static PorousMediumPermeability SquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
index 7fa748166c..847b8babbe 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerDensityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToPowerDensity
     /// </summary>
     public static class NumberToPowerDensityExtensions
     {
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicFoot(double)" />
         public static PowerDensity DecawattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static PowerDensity DecawattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromDecawattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicInch(double)" />
         public static PowerDensity DecawattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static PowerDensity DecawattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromDecawattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerCubicMeter(double)" />
         public static PowerDensity DecawattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static PowerDensity DecawattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromDecawattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromDecawattsPerLiter(double)" />
         public static PowerDensity DecawattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static PowerDensity DecawattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromDecawattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicFoot(double)" />
         public static PowerDensity DeciwattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static PowerDensity DeciwattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromDeciwattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicInch(double)" />
         public static PowerDensity DeciwattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static PowerDensity DeciwattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromDeciwattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerCubicMeter(double)" />
         public static PowerDensity DeciwattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static PowerDensity DeciwattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromDeciwattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromDeciwattsPerLiter(double)" />
         public static PowerDensity DeciwattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static PowerDensity DeciwattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromDeciwattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicFoot(double)" />
         public static PowerDensity GigawattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static PowerDensity GigawattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromGigawattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicInch(double)" />
         public static PowerDensity GigawattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static PowerDensity GigawattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromGigawattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerCubicMeter(double)" />
         public static PowerDensity GigawattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static PowerDensity GigawattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromGigawattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromGigawattsPerLiter(double)" />
         public static PowerDensity GigawattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static PowerDensity GigawattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromGigawattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicFoot(double)" />
         public static PowerDensity KilowattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static PowerDensity KilowattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromKilowattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicInch(double)" />
         public static PowerDensity KilowattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static PowerDensity KilowattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromKilowattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerCubicMeter(double)" />
         public static PowerDensity KilowattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static PowerDensity KilowattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromKilowattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromKilowattsPerLiter(double)" />
         public static PowerDensity KilowattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static PowerDensity KilowattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromKilowattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicFoot(double)" />
         public static PowerDensity MegawattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static PowerDensity MegawattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromMegawattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicInch(double)" />
         public static PowerDensity MegawattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static PowerDensity MegawattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromMegawattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerCubicMeter(double)" />
         public static PowerDensity MegawattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static PowerDensity MegawattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromMegawattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMegawattsPerLiter(double)" />
         public static PowerDensity MegawattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static PowerDensity MegawattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromMegawattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicFoot(double)" />
         public static PowerDensity MicrowattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static PowerDensity MicrowattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromMicrowattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicInch(double)" />
         public static PowerDensity MicrowattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static PowerDensity MicrowattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromMicrowattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerCubicMeter(double)" />
         public static PowerDensity MicrowattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static PowerDensity MicrowattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromMicrowattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMicrowattsPerLiter(double)" />
         public static PowerDensity MicrowattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static PowerDensity MicrowattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromMicrowattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicFoot(double)" />
         public static PowerDensity MilliwattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static PowerDensity MilliwattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromMilliwattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicInch(double)" />
         public static PowerDensity MilliwattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static PowerDensity MilliwattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromMilliwattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerCubicMeter(double)" />
         public static PowerDensity MilliwattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static PowerDensity MilliwattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromMilliwattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromMilliwattsPerLiter(double)" />
         public static PowerDensity MilliwattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static PowerDensity MilliwattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromMilliwattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicFoot(double)" />
         public static PowerDensity NanowattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static PowerDensity NanowattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromNanowattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicInch(double)" />
         public static PowerDensity NanowattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static PowerDensity NanowattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromNanowattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerCubicMeter(double)" />
         public static PowerDensity NanowattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static PowerDensity NanowattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromNanowattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromNanowattsPerLiter(double)" />
         public static PowerDensity NanowattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static PowerDensity NanowattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromNanowattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicFoot(double)" />
         public static PowerDensity PicowattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static PowerDensity PicowattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromPicowattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicInch(double)" />
         public static PowerDensity PicowattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static PowerDensity PicowattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromPicowattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerCubicMeter(double)" />
         public static PowerDensity PicowattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static PowerDensity PicowattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromPicowattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromPicowattsPerLiter(double)" />
         public static PowerDensity PicowattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static PowerDensity PicowattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromPicowattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicFoot(double)" />
         public static PowerDensity TerawattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static PowerDensity TerawattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromTerawattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicInch(double)" />
         public static PowerDensity TerawattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -336,7 +336,7 @@ public static PowerDensity TerawattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromTerawattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerCubicMeter(double)" />
         public static PowerDensity TerawattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -344,7 +344,7 @@ public static PowerDensity TerawattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromTerawattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromTerawattsPerLiter(double)" />
         public static PowerDensity TerawattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -352,7 +352,7 @@ public static PowerDensity TerawattsPerLiter<T>(this T value)
 #endif
             => PowerDensity.FromTerawattsPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicFoot(double)" />
         public static PowerDensity WattsPerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -360,7 +360,7 @@ public static PowerDensity WattsPerCubicFoot<T>(this T value)
 #endif
             => PowerDensity.FromWattsPerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicInch(double)" />
         public static PowerDensity WattsPerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -368,7 +368,7 @@ public static PowerDensity WattsPerCubicInch<T>(this T value)
 #endif
             => PowerDensity.FromWattsPerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromWattsPerCubicMeter(double)" />
         public static PowerDensity WattsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -376,7 +376,7 @@ public static PowerDensity WattsPerCubicMeter<T>(this T value)
 #endif
             => PowerDensity.FromWattsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerDensity.FromWattsPerLiter(double)" />
         public static PowerDensity WattsPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
index 2b5d37b0d8..8889adcf42 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToPower
     /// </summary>
     public static class NumberToPowerExtensions
     {
-        /// <inheritdoc cref="Power.FromBoilerHorsepower(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromBoilerHorsepower(double)" />
         public static Power BoilerHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Power BoilerHorsepower<T>(this T value)
 #endif
             => Power.FromBoilerHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromBritishThermalUnitsPerHour(double)" />
         public static Power BritishThermalUnitsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Power BritishThermalUnitsPerHour<T>(this T value)
 #endif
             => Power.FromBritishThermalUnitsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromDecawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromDecawatts(double)" />
         public static Power Decawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Power Decawatts<T>(this T value)
 #endif
             => Power.FromDecawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromDeciwatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromDeciwatts(double)" />
         public static Power Deciwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Power Deciwatts<T>(this T value)
 #endif
             => Power.FromDeciwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromElectricalHorsepower(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromElectricalHorsepower(double)" />
         public static Power ElectricalHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Power ElectricalHorsepower<T>(this T value)
 #endif
             => Power.FromElectricalHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromFemtowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromFemtowatts(double)" />
         public static Power Femtowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Power Femtowatts<T>(this T value)
 #endif
             => Power.FromFemtowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromGigajoulesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromGigajoulesPerHour(double)" />
         public static Power GigajoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Power GigajoulesPerHour<T>(this T value)
 #endif
             => Power.FromGigajoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromGigawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromGigawatts(double)" />
         public static Power Gigawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Power Gigawatts<T>(this T value)
 #endif
             => Power.FromGigawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromHydraulicHorsepower(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromHydraulicHorsepower(double)" />
         public static Power HydraulicHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Power HydraulicHorsepower<T>(this T value)
 #endif
             => Power.FromHydraulicHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromJoulesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromJoulesPerHour(double)" />
         public static Power JoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Power JoulesPerHour<T>(this T value)
 #endif
             => Power.FromJoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromKilobritishThermalUnitsPerHour(double)" />
         public static Power KilobritishThermalUnitsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Power KilobritishThermalUnitsPerHour<T>(this T value)
 #endif
             => Power.FromKilobritishThermalUnitsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromKilojoulesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromKilojoulesPerHour(double)" />
         public static Power KilojoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Power KilojoulesPerHour<T>(this T value)
 #endif
             => Power.FromKilojoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromKilowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromKilowatts(double)" />
         public static Power Kilowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Power Kilowatts<T>(this T value)
 #endif
             => Power.FromKilowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMechanicalHorsepower(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromMechanicalHorsepower(double)" />
         public static Power MechanicalHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Power MechanicalHorsepower<T>(this T value)
 #endif
             => Power.FromMechanicalHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMegabritishThermalUnitsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromMegabritishThermalUnitsPerHour(double)" />
         public static Power MegabritishThermalUnitsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Power MegabritishThermalUnitsPerHour<T>(this T value)
 #endif
             => Power.FromMegabritishThermalUnitsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMegajoulesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromMegajoulesPerHour(double)" />
         public static Power MegajoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Power MegajoulesPerHour<T>(this T value)
 #endif
             => Power.FromMegajoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMegawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromMegawatts(double)" />
         public static Power Megawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Power Megawatts<T>(this T value)
 #endif
             => Power.FromMegawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMetricHorsepower(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromMetricHorsepower(double)" />
         public static Power MetricHorsepower<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Power MetricHorsepower<T>(this T value)
 #endif
             => Power.FromMetricHorsepower(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMicrowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromMicrowatts(double)" />
         public static Power Microwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Power Microwatts<T>(this T value)
 #endif
             => Power.FromMicrowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMillijoulesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromMillijoulesPerHour(double)" />
         public static Power MillijoulesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Power MillijoulesPerHour<T>(this T value)
 #endif
             => Power.FromMillijoulesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromMilliwatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromMilliwatts(double)" />
         public static Power Milliwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Power Milliwatts<T>(this T value)
 #endif
             => Power.FromMilliwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromNanowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromNanowatts(double)" />
         public static Power Nanowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Power Nanowatts<T>(this T value)
 #endif
             => Power.FromNanowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromPetawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromPetawatts(double)" />
         public static Power Petawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Power Petawatts<T>(this T value)
 #endif
             => Power.FromPetawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromPicowatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromPicowatts(double)" />
         public static Power Picowatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Power Picowatts<T>(this T value)
 #endif
             => Power.FromPicowatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromTerawatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromTerawatts(double)" />
         public static Power Terawatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Power Terawatts<T>(this T value)
 #endif
             => Power.FromTerawatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Power.FromWatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Power.FromWatts(double)" />
         public static Power Watts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
index 37ccf44b67..19128fa14d 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPowerRatioExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToPowerRatio
     /// </summary>
     public static class NumberToPowerRatioExtensions
     {
-        /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerRatio.FromDecibelMilliwatts(double)" />
         public static PowerRatio DecibelMilliwatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static PowerRatio DecibelMilliwatts<T>(this T value)
 #endif
             => PowerRatio.FromDecibelMilliwatts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PowerRatio.FromDecibelWatts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PowerRatio.FromDecibelWatts(double)" />
         public static PowerRatio DecibelWatts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
index 586878daa4..3cc38f1321 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureChangeRateExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToPressureChangeRate
     /// </summary>
     public static class NumberToPressureChangeRateExtensions
     {
-        /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromAtmospheresPerSecond(double)" />
         public static PressureChangeRate AtmospheresPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static PressureChangeRate AtmospheresPerSecond<T>(this T value)
 #endif
             => PressureChangeRate.FromAtmospheresPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromBarsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromBarsPerMinute(double)" />
         public static PressureChangeRate BarsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static PressureChangeRate BarsPerMinute<T>(this T value)
 #endif
             => PressureChangeRate.FromBarsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromBarsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromBarsPerSecond(double)" />
         public static PressureChangeRate BarsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static PressureChangeRate BarsPerSecond<T>(this T value)
 #endif
             => PressureChangeRate.FromBarsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerMinute(double)" />
         public static PressureChangeRate KilopascalsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static PressureChangeRate KilopascalsPerMinute<T>(this T value)
 #endif
             => PressureChangeRate.FromKilopascalsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromKilopascalsPerSecond(double)" />
         public static PressureChangeRate KilopascalsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static PressureChangeRate KilopascalsPerSecond<T>(this T value)
 #endif
             => PressureChangeRate.FromKilopascalsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(double)" />
         public static PressureChangeRate KilopoundsForcePerSquareInchPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static PressureChangeRate KilopoundsForcePerSquareInchPerMinute<T>(this T
 #endif
             => PressureChangeRate.FromKilopoundsForcePerSquareInchPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(double)" />
         public static PressureChangeRate KilopoundsForcePerSquareInchPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static PressureChangeRate KilopoundsForcePerSquareInchPerSecond<T>(this T
 #endif
             => PressureChangeRate.FromKilopoundsForcePerSquareInchPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerMinute(double)" />
         public static PressureChangeRate MegapascalsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static PressureChangeRate MegapascalsPerMinute<T>(this T value)
 #endif
             => PressureChangeRate.FromMegapascalsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMegapascalsPerSecond(double)" />
         public static PressureChangeRate MegapascalsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static PressureChangeRate MegapascalsPerSecond<T>(this T value)
 #endif
             => PressureChangeRate.FromMegapascalsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(double)" />
         public static PressureChangeRate MegapoundsForcePerSquareInchPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static PressureChangeRate MegapoundsForcePerSquareInchPerMinute<T>(this T
 #endif
             => PressureChangeRate.FromMegapoundsForcePerSquareInchPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(double)" />
         public static PressureChangeRate MegapoundsForcePerSquareInchPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static PressureChangeRate MegapoundsForcePerSquareInchPerSecond<T>(this T
 #endif
             => PressureChangeRate.FromMegapoundsForcePerSquareInchPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerMinute(double)" />
         public static PressureChangeRate MillibarsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static PressureChangeRate MillibarsPerMinute<T>(this T value)
 #endif
             => PressureChangeRate.FromMillibarsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMillibarsPerSecond(double)" />
         public static PressureChangeRate MillibarsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static PressureChangeRate MillibarsPerSecond<T>(this T value)
 #endif
             => PressureChangeRate.FromMillibarsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromMillimetersOfMercuryPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromMillimetersOfMercuryPerSecond(double)" />
         public static PressureChangeRate MillimetersOfMercuryPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static PressureChangeRate MillimetersOfMercuryPerSecond<T>(this T value)
 #endif
             => PressureChangeRate.FromMillimetersOfMercuryPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerMinute(double)" />
         public static PressureChangeRate PascalsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static PressureChangeRate PascalsPerMinute<T>(this T value)
 #endif
             => PressureChangeRate.FromPascalsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromPascalsPerSecond(double)" />
         public static PressureChangeRate PascalsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static PressureChangeRate PascalsPerSecond<T>(this T value)
 #endif
             => PressureChangeRate.FromPascalsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(double)" />
         public static PressureChangeRate PoundsForcePerSquareInchPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static PressureChangeRate PoundsForcePerSquareInchPerMinute<T>(this T val
 #endif
             => PressureChangeRate.FromPoundsForcePerSquareInchPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="PressureChangeRate.FromPoundsForcePerSquareInchPerSecond(double)" />
         public static PressureChangeRate PoundsForcePerSquareInchPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
index 54cc9e7da8..3f3ef204b5 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToPressureExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToPressure
     /// </summary>
     public static class NumberToPressureExtensions
     {
-        /// <inheritdoc cref="Pressure.FromAtmospheres(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromAtmospheres(double)" />
         public static Pressure Atmospheres<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Pressure Atmospheres<T>(this T value)
 #endif
             => Pressure.FromAtmospheres(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromBars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromBars(double)" />
         public static Pressure Bars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Pressure Bars<T>(this T value)
 #endif
             => Pressure.FromBars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromCentibars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromCentibars(double)" />
         public static Pressure Centibars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Pressure Centibars<T>(this T value)
 #endif
             => Pressure.FromCentibars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromCentimetersOfWaterColumn(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromCentimetersOfWaterColumn(double)" />
         public static Pressure CentimetersOfWaterColumn<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Pressure CentimetersOfWaterColumn<T>(this T value)
 #endif
             => Pressure.FromCentimetersOfWaterColumn(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromDecapascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromDecapascals(double)" />
         public static Pressure Decapascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Pressure Decapascals<T>(this T value)
 #endif
             => Pressure.FromDecapascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromDecibars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromDecibars(double)" />
         public static Pressure Decibars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Pressure Decibars<T>(this T value)
 #endif
             => Pressure.FromDecibars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromDynesPerSquareCentimeter(double)" />
         public static Pressure DynesPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Pressure DynesPerSquareCentimeter<T>(this T value)
 #endif
             => Pressure.FromDynesPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromFeetOfElevation(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromFeetOfElevation(double)" />
         public static Pressure FeetOfElevation<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Pressure FeetOfElevation<T>(this T value)
 #endif
             => Pressure.FromFeetOfElevation(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromFeetOfHead(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromFeetOfHead(double)" />
         public static Pressure FeetOfHead<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Pressure FeetOfHead<T>(this T value)
 #endif
             => Pressure.FromFeetOfHead(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromGigapascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromGigapascals(double)" />
         public static Pressure Gigapascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Pressure Gigapascals<T>(this T value)
 #endif
             => Pressure.FromGigapascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromHectopascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromHectopascals(double)" />
         public static Pressure Hectopascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Pressure Hectopascals<T>(this T value)
 #endif
             => Pressure.FromHectopascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromInchesOfMercury(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromInchesOfMercury(double)" />
         public static Pressure InchesOfMercury<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Pressure InchesOfMercury<T>(this T value)
 #endif
             => Pressure.FromInchesOfMercury(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromInchesOfWaterColumn(double)" />
         public static Pressure InchesOfWaterColumn<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Pressure InchesOfWaterColumn<T>(this T value)
 #endif
             => Pressure.FromInchesOfWaterColumn(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilobars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilobars(double)" />
         public static Pressure Kilobars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Pressure Kilobars<T>(this T value)
 #endif
             => Pressure.FromKilobars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareCentimeter(double)" />
         public static Pressure KilogramsForcePerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Pressure KilogramsForcePerSquareCentimeter<T>(this T value)
 #endif
             => Pressure.FromKilogramsForcePerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMeter(double)" />
         public static Pressure KilogramsForcePerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Pressure KilogramsForcePerSquareMeter<T>(this T value)
 #endif
             => Pressure.FromKilogramsForcePerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilogramsForcePerSquareMillimeter(double)" />
         public static Pressure KilogramsForcePerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Pressure KilogramsForcePerSquareMillimeter<T>(this T value)
 #endif
             => Pressure.FromKilogramsForcePerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareCentimeter(double)" />
         public static Pressure KilonewtonsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Pressure KilonewtonsPerSquareCentimeter<T>(this T value)
 #endif
             => Pressure.FromKilonewtonsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMeter(double)" />
         public static Pressure KilonewtonsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Pressure KilonewtonsPerSquareMeter<T>(this T value)
 #endif
             => Pressure.FromKilonewtonsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilonewtonsPerSquareMillimeter(double)" />
         public static Pressure KilonewtonsPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Pressure KilonewtonsPerSquareMillimeter<T>(this T value)
 #endif
             => Pressure.FromKilonewtonsPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilopascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilopascals(double)" />
         public static Pressure Kilopascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Pressure Kilopascals<T>(this T value)
 #endif
             => Pressure.FromKilopascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareFoot(double)" />
         public static Pressure KilopoundsForcePerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Pressure KilopoundsForcePerSquareFoot<T>(this T value)
 #endif
             => Pressure.FromKilopoundsForcePerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareInch(double)" />
         public static Pressure KilopoundsForcePerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Pressure KilopoundsForcePerSquareInch<T>(this T value)
 #endif
             => Pressure.FromKilopoundsForcePerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareMil(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromKilopoundsForcePerSquareMil(double)" />
         public static Pressure KilopoundsForcePerSquareMil<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Pressure KilopoundsForcePerSquareMil<T>(this T value)
 #endif
             => Pressure.FromKilopoundsForcePerSquareMil(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMegabars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMegabars(double)" />
         public static Pressure Megabars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Pressure Megabars<T>(this T value)
 #endif
             => Pressure.FromMegabars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMeganewtonsPerSquareMeter(double)" />
         public static Pressure MeganewtonsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static Pressure MeganewtonsPerSquareMeter<T>(this T value)
 #endif
             => Pressure.FromMeganewtonsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMegapascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMegapascals(double)" />
         public static Pressure Megapascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static Pressure Megapascals<T>(this T value)
 #endif
             => Pressure.FromMegapascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMetersOfElevation(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMetersOfElevation(double)" />
         public static Pressure MetersOfElevation<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static Pressure MetersOfElevation<T>(this T value)
 #endif
             => Pressure.FromMetersOfElevation(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMetersOfHead(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMetersOfHead(double)" />
         public static Pressure MetersOfHead<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static Pressure MetersOfHead<T>(this T value)
 #endif
             => Pressure.FromMetersOfHead(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMetersOfWaterColumn(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMetersOfWaterColumn(double)" />
         public static Pressure MetersOfWaterColumn<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static Pressure MetersOfWaterColumn<T>(this T value)
 #endif
             => Pressure.FromMetersOfWaterColumn(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMicrobars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMicrobars(double)" />
         public static Pressure Microbars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static Pressure Microbars<T>(this T value)
 #endif
             => Pressure.FromMicrobars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMicropascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMicropascals(double)" />
         public static Pressure Micropascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static Pressure Micropascals<T>(this T value)
 #endif
             => Pressure.FromMicropascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMillibars(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMillibars(double)" />
         public static Pressure Millibars<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static Pressure Millibars<T>(this T value)
 #endif
             => Pressure.FromMillibars(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMillimetersOfMercury(double)" />
         public static Pressure MillimetersOfMercury<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static Pressure MillimetersOfMercury<T>(this T value)
 #endif
             => Pressure.FromMillimetersOfMercury(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMillimetersOfWaterColumn(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMillimetersOfWaterColumn(double)" />
         public static Pressure MillimetersOfWaterColumn<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static Pressure MillimetersOfWaterColumn<T>(this T value)
 #endif
             => Pressure.FromMillimetersOfWaterColumn(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromMillipascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromMillipascals(double)" />
         public static Pressure Millipascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static Pressure Millipascals<T>(this T value)
 #endif
             => Pressure.FromMillipascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareCentimeter(double)" />
         public static Pressure NewtonsPerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static Pressure NewtonsPerSquareCentimeter<T>(this T value)
 #endif
             => Pressure.FromNewtonsPerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMeter(double)" />
         public static Pressure NewtonsPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -336,7 +336,7 @@ public static Pressure NewtonsPerSquareMeter<T>(this T value)
 #endif
             => Pressure.FromNewtonsPerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromNewtonsPerSquareMillimeter(double)" />
         public static Pressure NewtonsPerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -344,7 +344,7 @@ public static Pressure NewtonsPerSquareMillimeter<T>(this T value)
 #endif
             => Pressure.FromNewtonsPerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPascals(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromPascals(double)" />
         public static Pressure Pascals<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -352,7 +352,7 @@ public static Pressure Pascals<T>(this T value)
 #endif
             => Pressure.FromPascals(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareFoot(double)" />
         public static Pressure PoundsForcePerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -360,7 +360,7 @@ public static Pressure PoundsForcePerSquareFoot<T>(this T value)
 #endif
             => Pressure.FromPoundsForcePerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareInch(double)" />
         public static Pressure PoundsForcePerSquareInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -368,7 +368,7 @@ public static Pressure PoundsForcePerSquareInch<T>(this T value)
 #endif
             => Pressure.FromPoundsForcePerSquareInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareMil(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromPoundsForcePerSquareMil(double)" />
         public static Pressure PoundsForcePerSquareMil<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -376,7 +376,7 @@ public static Pressure PoundsForcePerSquareMil<T>(this T value)
 #endif
             => Pressure.FromPoundsForcePerSquareMil(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromPoundsPerInchSecondSquared(double)" />
         public static Pressure PoundsPerInchSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -384,7 +384,7 @@ public static Pressure PoundsPerInchSecondSquared<T>(this T value)
 #endif
             => Pressure.FromPoundsPerInchSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromTechnicalAtmospheres(double)" />
         public static Pressure TechnicalAtmospheres<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -392,7 +392,7 @@ public static Pressure TechnicalAtmospheres<T>(this T value)
 #endif
             => Pressure.FromTechnicalAtmospheres(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareCentimeter(double)" />
         public static Pressure TonnesForcePerSquareCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -400,7 +400,7 @@ public static Pressure TonnesForcePerSquareCentimeter<T>(this T value)
 #endif
             => Pressure.FromTonnesForcePerSquareCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMeter(double)" />
         public static Pressure TonnesForcePerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -408,7 +408,7 @@ public static Pressure TonnesForcePerSquareMeter<T>(this T value)
 #endif
             => Pressure.FromTonnesForcePerSquareMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromTonnesForcePerSquareMillimeter(double)" />
         public static Pressure TonnesForcePerSquareMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -416,7 +416,7 @@ public static Pressure TonnesForcePerSquareMillimeter<T>(this T value)
 #endif
             => Pressure.FromTonnesForcePerSquareMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Pressure.FromTorrs(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Pressure.FromTorrs(double)" />
         public static Pressure Torrs<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationExposureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
index d24f2b7f0a..643106c73b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadiationExposureExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRadiationExposure
     /// </summary>
     public static class NumberToRadiationExposureExtensions
     {
-        /// <inheritdoc cref="RadiationExposure.FromCoulombsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RadiationExposure.FromCoulombsPerKilogram(double)" />
         public static RadiationExposure CoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static RadiationExposure CoulombsPerKilogram<T>(this T value)
 #endif
             => RadiationExposure.FromCoulombsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RadiationExposure.FromMicrocoulombsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RadiationExposure.FromMicrocoulombsPerKilogram(double)" />
         public static RadiationExposure MicrocoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static RadiationExposure MicrocoulombsPerKilogram<T>(this T value)
 #endif
             => RadiationExposure.FromMicrocoulombsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RadiationExposure.FromMicroroentgens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RadiationExposure.FromMicroroentgens(double)" />
         public static RadiationExposure Microroentgens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static RadiationExposure Microroentgens<T>(this T value)
 #endif
             => RadiationExposure.FromMicroroentgens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RadiationExposure.FromMillicoulombsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RadiationExposure.FromMillicoulombsPerKilogram(double)" />
         public static RadiationExposure MillicoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static RadiationExposure MillicoulombsPerKilogram<T>(this T value)
 #endif
             => RadiationExposure.FromMillicoulombsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RadiationExposure.FromMilliroentgens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RadiationExposure.FromMilliroentgens(double)" />
         public static RadiationExposure Milliroentgens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static RadiationExposure Milliroentgens<T>(this T value)
 #endif
             => RadiationExposure.FromMilliroentgens(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RadiationExposure.FromNanocoulombsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RadiationExposure.FromNanocoulombsPerKilogram(double)" />
         public static RadiationExposure NanocoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static RadiationExposure NanocoulombsPerKilogram<T>(this T value)
 #endif
             => RadiationExposure.FromNanocoulombsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RadiationExposure.FromPicocoulombsPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RadiationExposure.FromPicocoulombsPerKilogram(double)" />
         public static RadiationExposure PicocoulombsPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static RadiationExposure PicocoulombsPerKilogram<T>(this T value)
 #endif
             => RadiationExposure.FromPicocoulombsPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RadiationExposure.FromRoentgens(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RadiationExposure.FromRoentgens(double)" />
         public static RadiationExposure Roentgens<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadioactivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadioactivityExtensions.g.cs
index 59c3401ab6..b9ecd03de3 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadioactivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRadioactivityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRadioactivity
     /// </summary>
     public static class NumberToRadioactivityExtensions
     {
-        /// <inheritdoc cref="Radioactivity.FromBecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromBecquerels(double)" />
         public static Radioactivity Becquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Radioactivity Becquerels<T>(this T value)
 #endif
             => Radioactivity.FromBecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromCuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromCuries(double)" />
         public static Radioactivity Curies<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Radioactivity Curies<T>(this T value)
 #endif
             => Radioactivity.FromCuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromExabecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromExabecquerels(double)" />
         public static Radioactivity Exabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Radioactivity Exabecquerels<T>(this T value)
 #endif
             => Radioactivity.FromExabecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromGigabecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromGigabecquerels(double)" />
         public static Radioactivity Gigabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Radioactivity Gigabecquerels<T>(this T value)
 #endif
             => Radioactivity.FromGigabecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromGigacuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromGigacuries(double)" />
         public static Radioactivity Gigacuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Radioactivity Gigacuries<T>(this T value)
 #endif
             => Radioactivity.FromGigacuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromGigarutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromGigarutherfords(double)" />
         public static Radioactivity Gigarutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Radioactivity Gigarutherfords<T>(this T value)
 #endif
             => Radioactivity.FromGigarutherfords(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromKilobecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromKilobecquerels(double)" />
         public static Radioactivity Kilobecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Radioactivity Kilobecquerels<T>(this T value)
 #endif
             => Radioactivity.FromKilobecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromKilocuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromKilocuries(double)" />
         public static Radioactivity Kilocuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Radioactivity Kilocuries<T>(this T value)
 #endif
             => Radioactivity.FromKilocuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromKilorutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromKilorutherfords(double)" />
         public static Radioactivity Kilorutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Radioactivity Kilorutherfords<T>(this T value)
 #endif
             => Radioactivity.FromKilorutherfords(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMegabecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMegabecquerels(double)" />
         public static Radioactivity Megabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Radioactivity Megabecquerels<T>(this T value)
 #endif
             => Radioactivity.FromMegabecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMegacuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMegacuries(double)" />
         public static Radioactivity Megacuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Radioactivity Megacuries<T>(this T value)
 #endif
             => Radioactivity.FromMegacuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMegarutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMegarutherfords(double)" />
         public static Radioactivity Megarutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Radioactivity Megarutherfords<T>(this T value)
 #endif
             => Radioactivity.FromMegarutherfords(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMicrobecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMicrobecquerels(double)" />
         public static Radioactivity Microbecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Radioactivity Microbecquerels<T>(this T value)
 #endif
             => Radioactivity.FromMicrobecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMicrocuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMicrocuries(double)" />
         public static Radioactivity Microcuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Radioactivity Microcuries<T>(this T value)
 #endif
             => Radioactivity.FromMicrocuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMicrorutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMicrorutherfords(double)" />
         public static Radioactivity Microrutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Radioactivity Microrutherfords<T>(this T value)
 #endif
             => Radioactivity.FromMicrorutherfords(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMillibecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMillibecquerels(double)" />
         public static Radioactivity Millibecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Radioactivity Millibecquerels<T>(this T value)
 #endif
             => Radioactivity.FromMillibecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMillicuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMillicuries(double)" />
         public static Radioactivity Millicuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Radioactivity Millicuries<T>(this T value)
 #endif
             => Radioactivity.FromMillicuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromMillirutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromMillirutherfords(double)" />
         public static Radioactivity Millirutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Radioactivity Millirutherfords<T>(this T value)
 #endif
             => Radioactivity.FromMillirutherfords(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromNanobecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromNanobecquerels(double)" />
         public static Radioactivity Nanobecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Radioactivity Nanobecquerels<T>(this T value)
 #endif
             => Radioactivity.FromNanobecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromNanocuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromNanocuries(double)" />
         public static Radioactivity Nanocuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Radioactivity Nanocuries<T>(this T value)
 #endif
             => Radioactivity.FromNanocuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromNanorutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromNanorutherfords(double)" />
         public static Radioactivity Nanorutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Radioactivity Nanorutherfords<T>(this T value)
 #endif
             => Radioactivity.FromNanorutherfords(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromPetabecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromPetabecquerels(double)" />
         public static Radioactivity Petabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Radioactivity Petabecquerels<T>(this T value)
 #endif
             => Radioactivity.FromPetabecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromPicobecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromPicobecquerels(double)" />
         public static Radioactivity Picobecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Radioactivity Picobecquerels<T>(this T value)
 #endif
             => Radioactivity.FromPicobecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromPicocuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromPicocuries(double)" />
         public static Radioactivity Picocuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Radioactivity Picocuries<T>(this T value)
 #endif
             => Radioactivity.FromPicocuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromPicorutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromPicorutherfords(double)" />
         public static Radioactivity Picorutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Radioactivity Picorutherfords<T>(this T value)
 #endif
             => Radioactivity.FromPicorutherfords(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromRutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromRutherfords(double)" />
         public static Radioactivity Rutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static Radioactivity Rutherfords<T>(this T value)
 #endif
             => Radioactivity.FromRutherfords(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromTerabecquerels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromTerabecquerels(double)" />
         public static Radioactivity Terabecquerels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static Radioactivity Terabecquerels<T>(this T value)
 #endif
             => Radioactivity.FromTerabecquerels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromTeracuries(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromTeracuries(double)" />
         public static Radioactivity Teracuries<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static Radioactivity Teracuries<T>(this T value)
 #endif
             => Radioactivity.FromTeracuries(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Radioactivity.FromTerarutherfords(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Radioactivity.FromTerarutherfords(double)" />
         public static Radioactivity Terarutherfords<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
index cc38f32c1a..19bff685ff 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioChangeRateExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRatioChangeRate
     /// </summary>
     public static class NumberToRatioChangeRateExtensions
     {
-        /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RatioChangeRate.FromDecimalFractionsPerSecond(double)" />
         public static RatioChangeRate DecimalFractionsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static RatioChangeRate DecimalFractionsPerSecond<T>(this T value)
 #endif
             => RatioChangeRate.FromDecimalFractionsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RatioChangeRate.FromPercentsPerSecond(double)" />
         public static RatioChangeRate PercentsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
index 77bd15e366..4e13937c48 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRatioExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRatio
     /// </summary>
     public static class NumberToRatioExtensions
     {
-        /// <inheritdoc cref="Ratio.FromDecimalFractions(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Ratio.FromDecimalFractions(double)" />
         public static Ratio DecimalFractions<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Ratio DecimalFractions<T>(this T value)
 #endif
             => Ratio.FromDecimalFractions(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPartsPerBillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Ratio.FromPartsPerBillion(double)" />
         public static Ratio PartsPerBillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Ratio PartsPerBillion<T>(this T value)
 #endif
             => Ratio.FromPartsPerBillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPartsPerMillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Ratio.FromPartsPerMillion(double)" />
         public static Ratio PartsPerMillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Ratio PartsPerMillion<T>(this T value)
 #endif
             => Ratio.FromPartsPerMillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPartsPerThousand(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Ratio.FromPartsPerThousand(double)" />
         public static Ratio PartsPerThousand<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Ratio PartsPerThousand<T>(this T value)
 #endif
             => Ratio.FromPartsPerThousand(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Ratio.FromPartsPerTrillion(double)" />
         public static Ratio PartsPerTrillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Ratio PartsPerTrillion<T>(this T value)
 #endif
             => Ratio.FromPartsPerTrillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Ratio.FromPercent(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Ratio.FromPercent(double)" />
         public static Ratio Percent<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
index 9d49cd8dc4..57e2c4ee3f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactiveEnergyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToReactiveEnergy
     /// </summary>
     public static class NumberToReactiveEnergyExtensions
     {
-        /// <inheritdoc cref="ReactiveEnergy.FromKilovoltampereReactiveHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReactiveEnergy.FromKilovoltampereReactiveHours(double)" />
         public static ReactiveEnergy KilovoltampereReactiveHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ReactiveEnergy KilovoltampereReactiveHours<T>(this T value)
 #endif
             => ReactiveEnergy.FromKilovoltampereReactiveHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactiveEnergy.FromMegavoltampereReactiveHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReactiveEnergy.FromMegavoltampereReactiveHours(double)" />
         public static ReactiveEnergy MegavoltampereReactiveHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ReactiveEnergy MegavoltampereReactiveHours<T>(this T value)
 #endif
             => ReactiveEnergy.FromMegavoltampereReactiveHours(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactiveEnergy.FromVoltampereReactiveHours(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReactiveEnergy.FromVoltampereReactiveHours(double)" />
         public static ReactiveEnergy VoltampereReactiveHours<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
index cd418da760..70ffc0b7b0 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReactivePowerExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToReactivePower
     /// </summary>
     public static class NumberToReactivePowerExtensions
     {
-        /// <inheritdoc cref="ReactivePower.FromGigavoltamperesReactive(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReactivePower.FromGigavoltamperesReactive(double)" />
         public static ReactivePower GigavoltamperesReactive<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ReactivePower GigavoltamperesReactive<T>(this T value)
 #endif
             => ReactivePower.FromGigavoltamperesReactive(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactivePower.FromKilovoltamperesReactive(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReactivePower.FromKilovoltamperesReactive(double)" />
         public static ReactivePower KilovoltamperesReactive<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ReactivePower KilovoltamperesReactive<T>(this T value)
 #endif
             => ReactivePower.FromKilovoltamperesReactive(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactivePower.FromMegavoltamperesReactive(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReactivePower.FromMegavoltamperesReactive(double)" />
         public static ReactivePower MegavoltamperesReactive<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ReactivePower MegavoltamperesReactive<T>(this T value)
 #endif
             => ReactivePower.FromMegavoltamperesReactive(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReactivePower.FromVoltamperesReactive(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReactivePower.FromVoltamperesReactive(double)" />
         public static ReactivePower VoltamperesReactive<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
index 3ed970eca1..85b4bb1803 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalAreaExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToReciprocalArea
     /// </summary>
     public static class NumberToReciprocalAreaExtensions
     {
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareCentimeters(double)" />
         public static ReciprocalArea InverseSquareCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ReciprocalArea InverseSquareCentimeters<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareDecimeters(double)" />
         public static ReciprocalArea InverseSquareDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ReciprocalArea InverseSquareDecimeters<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareFeet(double)" />
         public static ReciprocalArea InverseSquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ReciprocalArea InverseSquareFeet<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareInches(double)" />
         public static ReciprocalArea InverseSquareInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ReciprocalArea InverseSquareInches<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareKilometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareKilometers(double)" />
         public static ReciprocalArea InverseSquareKilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ReciprocalArea InverseSquareKilometers<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareKilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMeters(double)" />
         public static ReciprocalArea InverseSquareMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ReciprocalArea InverseSquareMeters<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMicrometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMicrometers(double)" />
         public static ReciprocalArea InverseSquareMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static ReciprocalArea InverseSquareMicrometers<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareMicrometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMiles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMiles(double)" />
         public static ReciprocalArea InverseSquareMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static ReciprocalArea InverseSquareMiles<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareMillimeters(double)" />
         public static ReciprocalArea InverseSquareMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static ReciprocalArea InverseSquareMillimeters<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareYards(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseSquareYards(double)" />
         public static ReciprocalArea InverseSquareYards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static ReciprocalArea InverseSquareYards<T>(this T value)
 #endif
             => ReciprocalArea.FromInverseSquareYards(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalArea.FromInverseUsSurveySquareFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalArea.FromInverseUsSurveySquareFeet(double)" />
         public static ReciprocalArea InverseUsSurveySquareFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
index ded85d91ed..961f505c4c 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToReciprocalLengthExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToReciprocalLength
     /// </summary>
     public static class NumberToReciprocalLengthExtensions
     {
-        /// <inheritdoc cref="ReciprocalLength.FromInverseCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseCentimeters(double)" />
         public static ReciprocalLength InverseCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ReciprocalLength InverseCentimeters<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseFeet(double)" />
         public static ReciprocalLength InverseFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ReciprocalLength InverseFeet<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseInches(double)" />
         public static ReciprocalLength InverseInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ReciprocalLength InverseInches<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMeters(double)" />
         public static ReciprocalLength InverseMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ReciprocalLength InverseMeters<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMicroinches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMicroinches(double)" />
         public static ReciprocalLength InverseMicroinches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ReciprocalLength InverseMicroinches<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseMicroinches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMils(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMils(double)" />
         public static ReciprocalLength InverseMils<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static ReciprocalLength InverseMils<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseMils(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMiles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMiles(double)" />
         public static ReciprocalLength InverseMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static ReciprocalLength InverseMiles<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseMillimeters(double)" />
         public static ReciprocalLength InverseMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static ReciprocalLength InverseMillimeters<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseUsSurveyFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseUsSurveyFeet(double)" />
         public static ReciprocalLength InverseUsSurveyFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static ReciprocalLength InverseUsSurveyFeet<T>(this T value)
 #endif
             => ReciprocalLength.FromInverseUsSurveyFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ReciprocalLength.FromInverseYards(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ReciprocalLength.FromInverseYards(double)" />
         public static ReciprocalLength InverseYards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
index cd2a097145..a218c2130e 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRelativeHumidityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRelativeHumidity
     /// </summary>
     public static class NumberToRelativeHumidityExtensions
     {
-        /// <inheritdoc cref="RelativeHumidity.FromPercent(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RelativeHumidity.FromPercent(double)" />
         public static RelativeHumidity Percent<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
index 3a31967bf4..2fb64ce3fa 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalAccelerationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalAcceleration
     /// </summary>
     public static class NumberToRotationalAccelerationExtensions
     {
-        /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalAcceleration.FromDegreesPerSecondSquared(double)" />
         public static RotationalAcceleration DegreesPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static RotationalAcceleration DegreesPerSecondSquared<T>(this T value)
 #endif
             => RotationalAcceleration.FromDegreesPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalAcceleration.FromRadiansPerSecondSquared(double)" />
         public static RotationalAcceleration RadiansPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static RotationalAcceleration RadiansPerSecondSquared<T>(this T value)
 #endif
             => RotationalAcceleration.FromRadiansPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerMinutePerSecond(double)" />
         public static RotationalAcceleration RevolutionsPerMinutePerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static RotationalAcceleration RevolutionsPerMinutePerSecond<T>(this T val
 #endif
             => RotationalAcceleration.FromRevolutionsPerMinutePerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalAcceleration.FromRevolutionsPerSecondSquared(double)" />
         public static RotationalAcceleration RevolutionsPerSecondSquared<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
index a112c55846..2435e30aa9 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalSpeedExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalSpeed
     /// </summary>
     public static class NumberToRotationalSpeedExtensions
     {
-        /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromCentiradiansPerSecond(double)" />
         public static RotationalSpeed CentiradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static RotationalSpeed CentiradiansPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromCentiradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromDeciradiansPerSecond(double)" />
         public static RotationalSpeed DeciradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static RotationalSpeed DeciradiansPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromDeciradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerMinute(double)" />
         public static RotationalSpeed DegreesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static RotationalSpeed DegreesPerMinute<T>(this T value)
 #endif
             => RotationalSpeed.FromDegreesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromDegreesPerSecond(double)" />
         public static RotationalSpeed DegreesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static RotationalSpeed DegreesPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromDegreesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromMicrodegreesPerSecond(double)" />
         public static RotationalSpeed MicrodegreesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static RotationalSpeed MicrodegreesPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromMicrodegreesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromMicroradiansPerSecond(double)" />
         public static RotationalSpeed MicroradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static RotationalSpeed MicroradiansPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromMicroradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromMillidegreesPerSecond(double)" />
         public static RotationalSpeed MillidegreesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static RotationalSpeed MillidegreesPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromMillidegreesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromMilliradiansPerSecond(double)" />
         public static RotationalSpeed MilliradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static RotationalSpeed MilliradiansPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromMilliradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromNanodegreesPerSecond(double)" />
         public static RotationalSpeed NanodegreesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static RotationalSpeed NanodegreesPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromNanodegreesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromNanoradiansPerSecond(double)" />
         public static RotationalSpeed NanoradiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static RotationalSpeed NanoradiansPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromNanoradiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromRadiansPerSecond(double)" />
         public static RotationalSpeed RadiansPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static RotationalSpeed RadiansPerSecond<T>(this T value)
 #endif
             => RotationalSpeed.FromRadiansPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerMinute(double)" />
         public static RotationalSpeed RevolutionsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static RotationalSpeed RevolutionsPerMinute<T>(this T value)
 #endif
             => RotationalSpeed.FromRevolutionsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalSpeed.FromRevolutionsPerSecond(double)" />
         public static RotationalSpeed RevolutionsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
index 98179dc575..fa713661cb 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalStiffness
     /// </summary>
     public static class NumberToRotationalStiffnessExtensions
     {
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMetersPerDegree(double)" />
         public static RotationalStiffness CentinewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static RotationalStiffness CentinewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromCentinewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness CentinewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static RotationalStiffness CentinewtonMillimetersPerDegree<T>(this T valu
 #endif
             => RotationalStiffness.FromCentinewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromCentinewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness CentinewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static RotationalStiffness CentinewtonMillimetersPerRadian<T>(this T valu
 #endif
             => RotationalStiffness.FromCentinewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMetersPerDegree(double)" />
         public static RotationalStiffness DecanewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static RotationalStiffness DecanewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromDecanewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness DecanewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static RotationalStiffness DecanewtonMillimetersPerDegree<T>(this T value
 #endif
             => RotationalStiffness.FromDecanewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecanewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness DecanewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static RotationalStiffness DecanewtonMillimetersPerRadian<T>(this T value
 #endif
             => RotationalStiffness.FromDecanewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMetersPerDegree(double)" />
         public static RotationalStiffness DecinewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static RotationalStiffness DecinewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromDecinewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness DecinewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static RotationalStiffness DecinewtonMillimetersPerDegree<T>(this T value
 #endif
             => RotationalStiffness.FromDecinewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromDecinewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness DecinewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static RotationalStiffness DecinewtonMillimetersPerRadian<T>(this T value
 #endif
             => RotationalStiffness.FromDecinewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerDegree(double)" />
         public static RotationalStiffness KilonewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static RotationalStiffness KilonewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromKilonewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMetersPerRadian(double)" />
         public static RotationalStiffness KilonewtonMetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static RotationalStiffness KilonewtonMetersPerRadian<T>(this T value)
 #endif
             => RotationalStiffness.FromKilonewtonMetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness KilonewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static RotationalStiffness KilonewtonMillimetersPerDegree<T>(this T value
 #endif
             => RotationalStiffness.FromKilonewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilonewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness KilonewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static RotationalStiffness KilonewtonMillimetersPerRadian<T>(this T value
 #endif
             => RotationalStiffness.FromKilonewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerDegrees(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromKilopoundForceFeetPerDegrees(double)" />
         public static RotationalStiffness KilopoundForceFeetPerDegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static RotationalStiffness KilopoundForceFeetPerDegrees<T>(this T value)
 #endif
             => RotationalStiffness.FromKilopoundForceFeetPerDegrees(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerDegree(double)" />
         public static RotationalStiffness MeganewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static RotationalStiffness MeganewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromMeganewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMetersPerRadian(double)" />
         public static RotationalStiffness MeganewtonMetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static RotationalStiffness MeganewtonMetersPerRadian<T>(this T value)
 #endif
             => RotationalStiffness.FromMeganewtonMetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness MeganewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static RotationalStiffness MeganewtonMillimetersPerDegree<T>(this T value
 #endif
             => RotationalStiffness.FromMeganewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMeganewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness MeganewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static RotationalStiffness MeganewtonMillimetersPerRadian<T>(this T value
 #endif
             => RotationalStiffness.FromMeganewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMetersPerDegree(double)" />
         public static RotationalStiffness MicronewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static RotationalStiffness MicronewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromMicronewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness MicronewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static RotationalStiffness MicronewtonMillimetersPerDegree<T>(this T valu
 #endif
             => RotationalStiffness.FromMicronewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMicronewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness MicronewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static RotationalStiffness MicronewtonMillimetersPerRadian<T>(this T valu
 #endif
             => RotationalStiffness.FromMicronewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMetersPerDegree(double)" />
         public static RotationalStiffness MillinewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static RotationalStiffness MillinewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromMillinewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness MillinewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static RotationalStiffness MillinewtonMillimetersPerDegree<T>(this T valu
 #endif
             => RotationalStiffness.FromMillinewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromMillinewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness MillinewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static RotationalStiffness MillinewtonMillimetersPerRadian<T>(this T valu
 #endif
             => RotationalStiffness.FromMillinewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMetersPerDegree(double)" />
         public static RotationalStiffness NanonewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static RotationalStiffness NanonewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromNanonewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness NanonewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static RotationalStiffness NanonewtonMillimetersPerDegree<T>(this T value
 #endif
             => RotationalStiffness.FromNanonewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNanonewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness NanonewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static RotationalStiffness NanonewtonMillimetersPerRadian<T>(this T value
 #endif
             => RotationalStiffness.FromNanonewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerDegree(double)" />
         public static RotationalStiffness NewtonMetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static RotationalStiffness NewtonMetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromNewtonMetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMetersPerRadian(double)" />
         public static RotationalStiffness NewtonMetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static RotationalStiffness NewtonMetersPerRadian<T>(this T value)
 #endif
             => RotationalStiffness.FromNewtonMetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerDegree(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerDegree(double)" />
         public static RotationalStiffness NewtonMillimetersPerDegree<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static RotationalStiffness NewtonMillimetersPerDegree<T>(this T value)
 #endif
             => RotationalStiffness.FromNewtonMillimetersPerDegree(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromNewtonMillimetersPerRadian(double)" />
         public static RotationalStiffness NewtonMillimetersPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static RotationalStiffness NewtonMillimetersPerRadian<T>(this T value)
 #endif
             => RotationalStiffness.FromNewtonMillimetersPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerRadian(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerRadian(double)" />
         public static RotationalStiffness PoundForceFeetPerRadian<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static RotationalStiffness PoundForceFeetPerRadian<T>(this T value)
 #endif
             => RotationalStiffness.FromPoundForceFeetPerRadian(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerDegrees(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffness.FromPoundForceFeetPerDegrees(double)" />
         public static RotationalStiffness PoundForceFeetPerDegrees<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
index 26735a3ef5..61ca08cb9e 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToRotationalStiffnessPerLengthExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToRotationalStiffnessPerLength
     /// </summary>
     public static class NumberToRotationalStiffnessPerLengthExtensions
     {
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(double)" />
         public static RotationalStiffnessPerLength KilonewtonMetersPerRadianPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static RotationalStiffnessPerLength KilonewtonMetersPerRadianPerMeter<T>(
 #endif
             => RotationalStiffnessPerLength.FromKilonewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(double)" />
         public static RotationalStiffnessPerLength KilopoundForceFeetPerDegreesPerFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static RotationalStiffnessPerLength KilopoundForceFeetPerDegreesPerFeet<T
 #endif
             => RotationalStiffnessPerLength.FromKilopoundForceFeetPerDegreesPerFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(double)" />
         public static RotationalStiffnessPerLength MeganewtonMetersPerRadianPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static RotationalStiffnessPerLength MeganewtonMetersPerRadianPerMeter<T>(
 #endif
             => RotationalStiffnessPerLength.FromMeganewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(double)" />
         public static RotationalStiffnessPerLength NewtonMetersPerRadianPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static RotationalStiffnessPerLength NewtonMetersPerRadianPerMeter<T>(this
 #endif
             => RotationalStiffnessPerLength.FromNewtonMetersPerRadianPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="RotationalStiffnessPerLength.FromPoundForceFeetPerDegreesPerFeet(double)" />
         public static RotationalStiffnessPerLength PoundForceFeetPerDegreesPerFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToScalarExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToScalarExtensions.g.cs
index d5a54edf99..36ff683ac4 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToScalarExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToScalarExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToScalar
     /// </summary>
     public static class NumberToScalarExtensions
     {
-        /// <inheritdoc cref="Scalar.FromAmount(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Scalar.FromAmount(double)" />
         public static Scalar Amount<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
index 8fe95801c6..769ebf0a67 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSolidAngleExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToSolidAngle
     /// </summary>
     public static class NumberToSolidAngleExtensions
     {
-        /// <inheritdoc cref="SolidAngle.FromSteradians(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SolidAngle.FromSteradians(double)" />
         public static SolidAngle Steradians<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
index 2c4351e123..f94c47ccc1 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEnergyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificEnergy
     /// </summary>
     public static class NumberToSpecificEnergyExtensions
     {
-        /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromBtuPerPound(double)" />
         public static SpecificEnergy BtuPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static SpecificEnergy BtuPerPound<T>(this T value)
 #endif
             => SpecificEnergy.FromBtuPerPound(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromCaloriesPerGram(double)" />
         public static SpecificEnergy CaloriesPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static SpecificEnergy CaloriesPerGram<T>(this T value)
 #endif
             => SpecificEnergy.FromCaloriesPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerKilogram(double)" />
         public static SpecificEnergy GigawattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static SpecificEnergy GigawattDaysPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromGigawattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerShortTon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerShortTon(double)" />
         public static SpecificEnergy GigawattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static SpecificEnergy GigawattDaysPerShortTon<T>(this T value)
 #endif
             => SpecificEnergy.FromGigawattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerTonne(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattDaysPerTonne(double)" />
         public static SpecificEnergy GigawattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static SpecificEnergy GigawattDaysPerTonne<T>(this T value)
 #endif
             => SpecificEnergy.FromGigawattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerKilogram(double)" />
         public static SpecificEnergy GigawattHoursPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static SpecificEnergy GigawattHoursPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromGigawattHoursPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerPound(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromGigawattHoursPerPound(double)" />
         public static SpecificEnergy GigawattHoursPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static SpecificEnergy GigawattHoursPerPound<T>(this T value)
 #endif
             => SpecificEnergy.FromGigawattHoursPerPound(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromJoulesPerKilogram(double)" />
         public static SpecificEnergy JoulesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static SpecificEnergy JoulesPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromJoulesPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilocaloriesPerGram(double)" />
         public static SpecificEnergy KilocaloriesPerGram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static SpecificEnergy KilocaloriesPerGram<T>(this T value)
 #endif
             => SpecificEnergy.FromKilocaloriesPerGram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilojoulesPerKilogram(double)" />
         public static SpecificEnergy KilojoulesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static SpecificEnergy KilojoulesPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromKilojoulesPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerKilogram(double)" />
         public static SpecificEnergy KilowattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static SpecificEnergy KilowattDaysPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromKilowattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerShortTon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerShortTon(double)" />
         public static SpecificEnergy KilowattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static SpecificEnergy KilowattDaysPerShortTon<T>(this T value)
 #endif
             => SpecificEnergy.FromKilowattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerTonne(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattDaysPerTonne(double)" />
         public static SpecificEnergy KilowattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static SpecificEnergy KilowattDaysPerTonne<T>(this T value)
 #endif
             => SpecificEnergy.FromKilowattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerKilogram(double)" />
         public static SpecificEnergy KilowattHoursPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static SpecificEnergy KilowattHoursPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromKilowattHoursPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerPound(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromKilowattHoursPerPound(double)" />
         public static SpecificEnergy KilowattHoursPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static SpecificEnergy KilowattHoursPerPound<T>(this T value)
 #endif
             => SpecificEnergy.FromKilowattHoursPerPound(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegajoulesPerKilogram(double)" />
         public static SpecificEnergy MegajoulesPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static SpecificEnergy MegajoulesPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromMegajoulesPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegaJoulesPerTonne(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegaJoulesPerTonne(double)" />
         public static SpecificEnergy MegaJoulesPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static SpecificEnergy MegaJoulesPerTonne<T>(this T value)
 #endif
             => SpecificEnergy.FromMegaJoulesPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerKilogram(double)" />
         public static SpecificEnergy MegawattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static SpecificEnergy MegawattDaysPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromMegawattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerShortTon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerShortTon(double)" />
         public static SpecificEnergy MegawattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static SpecificEnergy MegawattDaysPerShortTon<T>(this T value)
 #endif
             => SpecificEnergy.FromMegawattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerTonne(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattDaysPerTonne(double)" />
         public static SpecificEnergy MegawattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static SpecificEnergy MegawattDaysPerTonne<T>(this T value)
 #endif
             => SpecificEnergy.FromMegawattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerKilogram(double)" />
         public static SpecificEnergy MegawattHoursPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static SpecificEnergy MegawattHoursPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromMegawattHoursPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerPound(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromMegawattHoursPerPound(double)" />
         public static SpecificEnergy MegawattHoursPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static SpecificEnergy MegawattHoursPerPound<T>(this T value)
 #endif
             => SpecificEnergy.FromMegawattHoursPerPound(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerKilogram(double)" />
         public static SpecificEnergy TerawattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static SpecificEnergy TerawattDaysPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromTerawattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerShortTon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerShortTon(double)" />
         public static SpecificEnergy TerawattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static SpecificEnergy TerawattDaysPerShortTon<T>(this T value)
 #endif
             => SpecificEnergy.FromTerawattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerTonne(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromTerawattDaysPerTonne(double)" />
         public static SpecificEnergy TerawattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static SpecificEnergy TerawattDaysPerTonne<T>(this T value)
 #endif
             => SpecificEnergy.FromTerawattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerKilogram(double)" />
         public static SpecificEnergy WattDaysPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static SpecificEnergy WattDaysPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromWattDaysPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerShortTon(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerShortTon(double)" />
         public static SpecificEnergy WattDaysPerShortTon<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static SpecificEnergy WattDaysPerShortTon<T>(this T value)
 #endif
             => SpecificEnergy.FromWattDaysPerShortTon(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerTonne(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattDaysPerTonne(double)" />
         public static SpecificEnergy WattDaysPerTonne<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static SpecificEnergy WattDaysPerTonne<T>(this T value)
 #endif
             => SpecificEnergy.FromWattDaysPerTonne(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerKilogram(double)" />
         public static SpecificEnergy WattHoursPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static SpecificEnergy WattHoursPerKilogram<T>(this T value)
 #endif
             => SpecificEnergy.FromWattHoursPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerPound(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEnergy.FromWattHoursPerPound(double)" />
         public static SpecificEnergy WattHoursPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
index bf2479f834..b84168a527 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificEntropyExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificEntropy
     /// </summary>
     public static class NumberToSpecificEntropyExtensions
     {
-        /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromBtusPerPoundFahrenheit(double)" />
         public static SpecificEntropy BtusPerPoundFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static SpecificEntropy BtusPerPoundFahrenheit<T>(this T value)
 #endif
             => SpecificEntropy.FromBtusPerPoundFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromCaloriesPerGramKelvin(double)" />
         public static SpecificEntropy CaloriesPerGramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static SpecificEntropy CaloriesPerGramKelvin<T>(this T value)
 #endif
             => SpecificEntropy.FromCaloriesPerGramKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(double)" />
         public static SpecificEntropy JoulesPerKilogramDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static SpecificEntropy JoulesPerKilogramDegreeCelsius<T>(this T value)
 #endif
             => SpecificEntropy.FromJoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromJoulesPerKilogramKelvin(double)" />
         public static SpecificEntropy JoulesPerKilogramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static SpecificEntropy JoulesPerKilogramKelvin<T>(this T value)
 #endif
             => SpecificEntropy.FromJoulesPerKilogramKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromKilocaloriesPerGramKelvin(double)" />
         public static SpecificEntropy KilocaloriesPerGramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static SpecificEntropy KilocaloriesPerGramKelvin<T>(this T value)
 #endif
             => SpecificEntropy.FromKilocaloriesPerGramKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(double)" />
         public static SpecificEntropy KilojoulesPerKilogramDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static SpecificEntropy KilojoulesPerKilogramDegreeCelsius<T>(this T value
 #endif
             => SpecificEntropy.FromKilojoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromKilojoulesPerKilogramKelvin(double)" />
         public static SpecificEntropy KilojoulesPerKilogramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static SpecificEntropy KilojoulesPerKilogramKelvin<T>(this T value)
 #endif
             => SpecificEntropy.FromKilojoulesPerKilogramKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(double)" />
         public static SpecificEntropy MegajoulesPerKilogramDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static SpecificEntropy MegajoulesPerKilogramDegreeCelsius<T>(this T value
 #endif
             => SpecificEntropy.FromMegajoulesPerKilogramDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificEntropy.FromMegajoulesPerKilogramKelvin(double)" />
         public static SpecificEntropy MegajoulesPerKilogramKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
index 4dd990820b..0d6dc5a674 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificFuelConsumptionExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificFuelConsumption
     /// </summary>
     public static class NumberToSpecificFuelConsumptionExtensions
     {
-        /// <inheritdoc cref="SpecificFuelConsumption.FromGramsPerKiloNewtonSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificFuelConsumption.FromGramsPerKiloNewtonSecond(double)" />
         public static SpecificFuelConsumption GramsPerKiloNewtonSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static SpecificFuelConsumption GramsPerKiloNewtonSecond<T>(this T value)
 #endif
             => SpecificFuelConsumption.FromGramsPerKiloNewtonSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(double)" />
         public static SpecificFuelConsumption KilogramsPerKilogramForceHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static SpecificFuelConsumption KilogramsPerKilogramForceHour<T>(this T va
 #endif
             => SpecificFuelConsumption.FromKilogramsPerKilogramForceHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKiloNewtonSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificFuelConsumption.FromKilogramsPerKiloNewtonSecond(double)" />
         public static SpecificFuelConsumption KilogramsPerKiloNewtonSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static SpecificFuelConsumption KilogramsPerKiloNewtonSecond<T>(this T val
 #endif
             => SpecificFuelConsumption.FromKilogramsPerKiloNewtonSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificFuelConsumption.FromPoundsMassPerPoundForceHour(double)" />
         public static SpecificFuelConsumption PoundsMassPerPoundForceHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
index f6224fa844..786ff59b03 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificVolumeExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificVolume
     /// </summary>
     public static class NumberToSpecificVolumeExtensions
     {
-        /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificVolume.FromCubicFeetPerPound(double)" />
         public static SpecificVolume CubicFeetPerPound<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static SpecificVolume CubicFeetPerPound<T>(this T value)
 #endif
             => SpecificVolume.FromCubicFeetPerPound(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificVolume.FromCubicMetersPerKilogram(double)" />
         public static SpecificVolume CubicMetersPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static SpecificVolume CubicMetersPerKilogram<T>(this T value)
 #endif
             => SpecificVolume.FromCubicMetersPerKilogram(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificVolume.FromMillicubicMetersPerKilogram(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificVolume.FromMillicubicMetersPerKilogram(double)" />
         public static SpecificVolume MillicubicMetersPerKilogram<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
index aa28a83c2a..5a77413b77 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpecificWeightExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToSpecificWeight
     /// </summary>
     public static class NumberToSpecificWeightExtensions
     {
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicCentimeter(double)" />
         public static SpecificWeight KilogramsForcePerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static SpecificWeight KilogramsForcePerCubicCentimeter<T>(this T value)
 #endif
             => SpecificWeight.FromKilogramsForcePerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMeter(double)" />
         public static SpecificWeight KilogramsForcePerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static SpecificWeight KilogramsForcePerCubicMeter<T>(this T value)
 #endif
             => SpecificWeight.FromKilogramsForcePerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilogramsForcePerCubicMillimeter(double)" />
         public static SpecificWeight KilogramsForcePerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static SpecificWeight KilogramsForcePerCubicMillimeter<T>(this T value)
 #endif
             => SpecificWeight.FromKilogramsForcePerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicCentimeter(double)" />
         public static SpecificWeight KilonewtonsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static SpecificWeight KilonewtonsPerCubicCentimeter<T>(this T value)
 #endif
             => SpecificWeight.FromKilonewtonsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMeter(double)" />
         public static SpecificWeight KilonewtonsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static SpecificWeight KilonewtonsPerCubicMeter<T>(this T value)
 #endif
             => SpecificWeight.FromKilonewtonsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilonewtonsPerCubicMillimeter(double)" />
         public static SpecificWeight KilonewtonsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static SpecificWeight KilonewtonsPerCubicMillimeter<T>(this T value)
 #endif
             => SpecificWeight.FromKilonewtonsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicFoot(double)" />
         public static SpecificWeight KilopoundsForcePerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static SpecificWeight KilopoundsForcePerCubicFoot<T>(this T value)
 #endif
             => SpecificWeight.FromKilopoundsForcePerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromKilopoundsForcePerCubicInch(double)" />
         public static SpecificWeight KilopoundsForcePerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static SpecificWeight KilopoundsForcePerCubicInch<T>(this T value)
 #endif
             => SpecificWeight.FromKilopoundsForcePerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromMeganewtonsPerCubicMeter(double)" />
         public static SpecificWeight MeganewtonsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static SpecificWeight MeganewtonsPerCubicMeter<T>(this T value)
 #endif
             => SpecificWeight.FromMeganewtonsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicCentimeter(double)" />
         public static SpecificWeight NewtonsPerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static SpecificWeight NewtonsPerCubicCentimeter<T>(this T value)
 #endif
             => SpecificWeight.FromNewtonsPerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMeter(double)" />
         public static SpecificWeight NewtonsPerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static SpecificWeight NewtonsPerCubicMeter<T>(this T value)
 #endif
             => SpecificWeight.FromNewtonsPerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromNewtonsPerCubicMillimeter(double)" />
         public static SpecificWeight NewtonsPerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static SpecificWeight NewtonsPerCubicMillimeter<T>(this T value)
 #endif
             => SpecificWeight.FromNewtonsPerCubicMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicFoot(double)" />
         public static SpecificWeight PoundsForcePerCubicFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static SpecificWeight PoundsForcePerCubicFoot<T>(this T value)
 #endif
             => SpecificWeight.FromPoundsForcePerCubicFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromPoundsForcePerCubicInch(double)" />
         public static SpecificWeight PoundsForcePerCubicInch<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static SpecificWeight PoundsForcePerCubicInch<T>(this T value)
 #endif
             => SpecificWeight.FromPoundsForcePerCubicInch(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicCentimeter(double)" />
         public static SpecificWeight TonnesForcePerCubicCentimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static SpecificWeight TonnesForcePerCubicCentimeter<T>(this T value)
 #endif
             => SpecificWeight.FromTonnesForcePerCubicCentimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMeter(double)" />
         public static SpecificWeight TonnesForcePerCubicMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static SpecificWeight TonnesForcePerCubicMeter<T>(this T value)
 #endif
             => SpecificWeight.FromTonnesForcePerCubicMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="SpecificWeight.FromTonnesForcePerCubicMillimeter(double)" />
         public static SpecificWeight TonnesForcePerCubicMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
index 956e9ae248..eacd11c94f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToSpeedExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToSpeed
     /// </summary>
     public static class NumberToSpeedExtensions
     {
-        /// <inheritdoc cref="Speed.FromCentimetersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromCentimetersPerHour(double)" />
         public static Speed CentimetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Speed CentimetersPerHour<T>(this T value)
 #endif
             => Speed.FromCentimetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromCentimetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromCentimetersPerMinute(double)" />
         public static Speed CentimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Speed CentimetersPerMinute<T>(this T value)
 #endif
             => Speed.FromCentimetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromCentimetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromCentimetersPerSecond(double)" />
         public static Speed CentimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Speed CentimetersPerSecond<T>(this T value)
 #endif
             => Speed.FromCentimetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromDecimetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromDecimetersPerMinute(double)" />
         public static Speed DecimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Speed DecimetersPerMinute<T>(this T value)
 #endif
             => Speed.FromDecimetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromDecimetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromDecimetersPerSecond(double)" />
         public static Speed DecimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Speed DecimetersPerSecond<T>(this T value)
 #endif
             => Speed.FromDecimetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromFeetPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromFeetPerHour(double)" />
         public static Speed FeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Speed FeetPerHour<T>(this T value)
 #endif
             => Speed.FromFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromFeetPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromFeetPerMinute(double)" />
         public static Speed FeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Speed FeetPerMinute<T>(this T value)
 #endif
             => Speed.FromFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromFeetPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromFeetPerSecond(double)" />
         public static Speed FeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Speed FeetPerSecond<T>(this T value)
 #endif
             => Speed.FromFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromInchesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromInchesPerHour(double)" />
         public static Speed InchesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Speed InchesPerHour<T>(this T value)
 #endif
             => Speed.FromInchesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromInchesPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromInchesPerMinute(double)" />
         public static Speed InchesPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Speed InchesPerMinute<T>(this T value)
 #endif
             => Speed.FromInchesPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromInchesPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromInchesPerSecond(double)" />
         public static Speed InchesPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Speed InchesPerSecond<T>(this T value)
 #endif
             => Speed.FromInchesPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromKilometersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromKilometersPerHour(double)" />
         public static Speed KilometersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Speed KilometersPerHour<T>(this T value)
 #endif
             => Speed.FromKilometersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromKilometersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromKilometersPerMinute(double)" />
         public static Speed KilometersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Speed KilometersPerMinute<T>(this T value)
 #endif
             => Speed.FromKilometersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromKilometersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromKilometersPerSecond(double)" />
         public static Speed KilometersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Speed KilometersPerSecond<T>(this T value)
 #endif
             => Speed.FromKilometersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromKnots(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromKnots(double)" />
         public static Speed Knots<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Speed Knots<T>(this T value)
 #endif
             => Speed.FromKnots(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMach(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMach(double)" />
         public static Speed Mach<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Speed Mach<T>(this T value)
 #endif
             => Speed.FromMach(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMetersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMetersPerHour(double)" />
         public static Speed MetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Speed MetersPerHour<T>(this T value)
 #endif
             => Speed.FromMetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMetersPerMinute(double)" />
         public static Speed MetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Speed MetersPerMinute<T>(this T value)
 #endif
             => Speed.FromMetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMetersPerSecond(double)" />
         public static Speed MetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Speed MetersPerSecond<T>(this T value)
 #endif
             => Speed.FromMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMicrometersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMicrometersPerMinute(double)" />
         public static Speed MicrometersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Speed MicrometersPerMinute<T>(this T value)
 #endif
             => Speed.FromMicrometersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMicrometersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMicrometersPerSecond(double)" />
         public static Speed MicrometersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Speed MicrometersPerSecond<T>(this T value)
 #endif
             => Speed.FromMicrometersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMilesPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMilesPerHour(double)" />
         public static Speed MilesPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Speed MilesPerHour<T>(this T value)
 #endif
             => Speed.FromMilesPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMillimetersPerHour(double)" />
         public static Speed MillimetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Speed MillimetersPerHour<T>(this T value)
 #endif
             => Speed.FromMillimetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMillimetersPerMinute(double)" />
         public static Speed MillimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Speed MillimetersPerMinute<T>(this T value)
 #endif
             => Speed.FromMillimetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromMillimetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromMillimetersPerSecond(double)" />
         public static Speed MillimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Speed MillimetersPerSecond<T>(this T value)
 #endif
             => Speed.FromMillimetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromNanometersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromNanometersPerMinute(double)" />
         public static Speed NanometersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static Speed NanometersPerMinute<T>(this T value)
 #endif
             => Speed.FromNanometersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromNanometersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromNanometersPerSecond(double)" />
         public static Speed NanometersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static Speed NanometersPerSecond<T>(this T value)
 #endif
             => Speed.FromNanometersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerHour(double)" />
         public static Speed UsSurveyFeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static Speed UsSurveyFeetPerHour<T>(this T value)
 #endif
             => Speed.FromUsSurveyFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerMinute(double)" />
         public static Speed UsSurveyFeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static Speed UsSurveyFeetPerMinute<T>(this T value)
 #endif
             => Speed.FromUsSurveyFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromUsSurveyFeetPerSecond(double)" />
         public static Speed UsSurveyFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static Speed UsSurveyFeetPerSecond<T>(this T value)
 #endif
             => Speed.FromUsSurveyFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromYardsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromYardsPerHour(double)" />
         public static Speed YardsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static Speed YardsPerHour<T>(this T value)
 #endif
             => Speed.FromYardsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromYardsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromYardsPerMinute(double)" />
         public static Speed YardsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static Speed YardsPerMinute<T>(this T value)
 #endif
             => Speed.FromYardsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Speed.FromYardsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Speed.FromYardsPerSecond(double)" />
         public static Speed YardsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
index 5d6d12ebb6..f16a65fe3b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToStandardVolumeFlowExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToStandardVolumeFlow
     /// </summary>
     public static class NumberToStandardVolumeFlowExtensions
     {
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(double)" />
         public static StandardVolumeFlow StandardCubicCentimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static StandardVolumeFlow StandardCubicCentimetersPerMinute<T>(this T val
 #endif
             => StandardVolumeFlow.FromStandardCubicCentimetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerHour(double)" />
         public static StandardVolumeFlow StandardCubicFeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static StandardVolumeFlow StandardCubicFeetPerHour<T>(this T value)
 #endif
             => StandardVolumeFlow.FromStandardCubicFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerMinute(double)" />
         public static StandardVolumeFlow StandardCubicFeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static StandardVolumeFlow StandardCubicFeetPerMinute<T>(this T value)
 #endif
             => StandardVolumeFlow.FromStandardCubicFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicFeetPerSecond(double)" />
         public static StandardVolumeFlow StandardCubicFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static StandardVolumeFlow StandardCubicFeetPerSecond<T>(this T value)
 #endif
             => StandardVolumeFlow.FromStandardCubicFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerDay(double)" />
         public static StandardVolumeFlow StandardCubicMetersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static StandardVolumeFlow StandardCubicMetersPerDay<T>(this T value)
 #endif
             => StandardVolumeFlow.FromStandardCubicMetersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerHour(double)" />
         public static StandardVolumeFlow StandardCubicMetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static StandardVolumeFlow StandardCubicMetersPerHour<T>(this T value)
 #endif
             => StandardVolumeFlow.FromStandardCubicMetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerMinute(double)" />
         public static StandardVolumeFlow StandardCubicMetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static StandardVolumeFlow StandardCubicMetersPerMinute<T>(this T value)
 #endif
             => StandardVolumeFlow.FromStandardCubicMetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardCubicMetersPerSecond(double)" />
         public static StandardVolumeFlow StandardCubicMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static StandardVolumeFlow StandardCubicMetersPerSecond<T>(this T value)
 #endif
             => StandardVolumeFlow.FromStandardCubicMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="StandardVolumeFlow.FromStandardLitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="StandardVolumeFlow.FromStandardLitersPerMinute(double)" />
         public static StandardVolumeFlow StandardLitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
index 98d8dfae29..c54cba19b9 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureChangeRateExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToTemperatureChangeRate
     /// </summary>
     public static class NumberToTemperatureChangeRateExtensions
     {
-        /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate CentidegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static TemperatureChangeRate CentidegreesCelsiusPerSecond<T>(this T value
 #endif
             => TemperatureChangeRate.FromCentidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate DecadegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static TemperatureChangeRate DecadegreesCelsiusPerSecond<T>(this T value)
 #endif
             => TemperatureChangeRate.FromDecadegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate DecidegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static TemperatureChangeRate DecidegreesCelsiusPerSecond<T>(this T value)
 #endif
             => TemperatureChangeRate.FromDecidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerMinute(double)" />
         public static TemperatureChangeRate DegreesCelsiusPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static TemperatureChangeRate DegreesCelsiusPerMinute<T>(this T value)
 #endif
             => TemperatureChangeRate.FromDegreesCelsiusPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromDegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate DegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static TemperatureChangeRate DegreesCelsiusPerSecond<T>(this T value)
 #endif
             => TemperatureChangeRate.FromDegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate HectodegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static TemperatureChangeRate HectodegreesCelsiusPerSecond<T>(this T value
 #endif
             => TemperatureChangeRate.FromHectodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate KilodegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static TemperatureChangeRate KilodegreesCelsiusPerSecond<T>(this T value)
 #endif
             => TemperatureChangeRate.FromKilodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate MicrodegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static TemperatureChangeRate MicrodegreesCelsiusPerSecond<T>(this T value
 #endif
             => TemperatureChangeRate.FromMicrodegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate MillidegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static TemperatureChangeRate MillidegreesCelsiusPerSecond<T>(this T value
 #endif
             => TemperatureChangeRate.FromMillidegreesCelsiusPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureChangeRate.FromNanodegreesCelsiusPerSecond(double)" />
         public static TemperatureChangeRate NanodegreesCelsiusPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
index dd92e8f190..1411f8e573 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureDeltaExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToTemperatureDelta
     /// </summary>
     public static class NumberToTemperatureDeltaExtensions
     {
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesCelsius(double)" />
         public static TemperatureDelta DegreesCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static TemperatureDelta DegreesCelsius<T>(this T value)
 #endif
             => TemperatureDelta.FromDegreesCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesDelisle(double)" />
         public static TemperatureDelta DegreesDelisle<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static TemperatureDelta DegreesDelisle<T>(this T value)
 #endif
             => TemperatureDelta.FromDegreesDelisle(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesFahrenheit(double)" />
         public static TemperatureDelta DegreesFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static TemperatureDelta DegreesFahrenheit<T>(this T value)
 #endif
             => TemperatureDelta.FromDegreesFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesNewton(double)" />
         public static TemperatureDelta DegreesNewton<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static TemperatureDelta DegreesNewton<T>(this T value)
 #endif
             => TemperatureDelta.FromDegreesNewton(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesRankine(double)" />
         public static TemperatureDelta DegreesRankine<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static TemperatureDelta DegreesRankine<T>(this T value)
 #endif
             => TemperatureDelta.FromDegreesRankine(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesReaumur(double)" />
         public static TemperatureDelta DegreesReaumur<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static TemperatureDelta DegreesReaumur<T>(this T value)
 #endif
             => TemperatureDelta.FromDegreesReaumur(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromDegreesRoemer(double)" />
         public static TemperatureDelta DegreesRoemer<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static TemperatureDelta DegreesRoemer<T>(this T value)
 #endif
             => TemperatureDelta.FromDegreesRoemer(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromKelvins(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromKelvins(double)" />
         public static TemperatureDelta Kelvins<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static TemperatureDelta Kelvins<T>(this T value)
 #endif
             => TemperatureDelta.FromKelvins(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureDelta.FromMillidegreesCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureDelta.FromMillidegreesCelsius(double)" />
         public static TemperatureDelta MillidegreesCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
index c739bab623..c49aa4c8a2 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToTemperature
     /// </summary>
     public static class NumberToTemperatureExtensions
     {
-        /// <inheritdoc cref="Temperature.FromDegreesCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromDegreesCelsius(double)" />
         public static Temperature DegreesCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Temperature DegreesCelsius<T>(this T value)
 #endif
             => Temperature.FromDegreesCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesDelisle(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromDegreesDelisle(double)" />
         public static Temperature DegreesDelisle<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Temperature DegreesDelisle<T>(this T value)
 #endif
             => Temperature.FromDegreesDelisle(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromDegreesFahrenheit(double)" />
         public static Temperature DegreesFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Temperature DegreesFahrenheit<T>(this T value)
 #endif
             => Temperature.FromDegreesFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesNewton(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromDegreesNewton(double)" />
         public static Temperature DegreesNewton<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Temperature DegreesNewton<T>(this T value)
 #endif
             => Temperature.FromDegreesNewton(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesRankine(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromDegreesRankine(double)" />
         public static Temperature DegreesRankine<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Temperature DegreesRankine<T>(this T value)
 #endif
             => Temperature.FromDegreesRankine(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesReaumur(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromDegreesReaumur(double)" />
         public static Temperature DegreesReaumur<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Temperature DegreesReaumur<T>(this T value)
 #endif
             => Temperature.FromDegreesReaumur(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromDegreesRoemer(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromDegreesRoemer(double)" />
         public static Temperature DegreesRoemer<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Temperature DegreesRoemer<T>(this T value)
 #endif
             => Temperature.FromDegreesRoemer(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromKelvins(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromKelvins(double)" />
         public static Temperature Kelvins<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Temperature Kelvins<T>(this T value)
 #endif
             => Temperature.FromKelvins(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromMillidegreesCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromMillidegreesCelsius(double)" />
         public static Temperature MillidegreesCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Temperature MillidegreesCelsius<T>(this T value)
 #endif
             => Temperature.FromMillidegreesCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Temperature.FromSolarTemperatures(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Temperature.FromSolarTemperatures(double)" />
         public static Temperature SolarTemperatures<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
index b12ee6e3bb..72f787a472 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTemperatureGradientExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToTemperatureGradient
     /// </summary>
     public static class NumberToTemperatureGradientExtensions
     {
-        /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerKilometer(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerKilometer(double)" />
         public static TemperatureGradient DegreesCelsiusPerKilometer<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static TemperatureGradient DegreesCelsiusPerKilometer<T>(this T value)
 #endif
             => TemperatureGradient.FromDegreesCelsiusPerKilometer(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureGradient.FromDegreesCelsiusPerMeter(double)" />
         public static TemperatureGradient DegreesCelsiusPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static TemperatureGradient DegreesCelsiusPerMeter<T>(this T value)
 #endif
             => TemperatureGradient.FromDegreesCelsiusPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureGradient.FromDegreesFahrenheitPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureGradient.FromDegreesFahrenheitPerFoot(double)" />
         public static TemperatureGradient DegreesFahrenheitPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static TemperatureGradient DegreesFahrenheitPerFoot<T>(this T value)
 #endif
             => TemperatureGradient.FromDegreesFahrenheitPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TemperatureGradient.FromKelvinsPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TemperatureGradient.FromKelvinsPerMeter(double)" />
         public static TemperatureGradient KelvinsPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
index c516bf8fa2..1342e6ed08 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalConductivityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToThermalConductivity
     /// </summary>
     public static class NumberToThermalConductivityExtensions
     {
-        /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ThermalConductivity.FromBtusPerHourFootFahrenheit(double)" />
         public static ThermalConductivity BtusPerHourFootFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ThermalConductivity BtusPerHourFootFahrenheit<T>(this T value)
 #endif
             => ThermalConductivity.FromBtusPerHourFootFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ThermalConductivity.FromWattsPerMeterKelvin(double)" />
         public static ThermalConductivity WattsPerMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
index 2751d33ad0..c2750af1da 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToThermalResistanceExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToThermalResistance
     /// </summary>
     public static class NumberToThermalResistanceExtensions
     {
-        /// <inheritdoc cref="ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(double)" />
         public static ThermalResistance HourSquareFeetDegreesFahrenheitPerBtu<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static ThermalResistance HourSquareFeetDegreesFahrenheitPerBtu<T>(this T
 #endif
             => ThermalResistance.FromHourSquareFeetDegreesFahrenheitPerBtu(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double)" />
         public static ThermalResistance SquareCentimeterHourDegreesCelsiusPerKilocalorie<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static ThermalResistance SquareCentimeterHourDegreesCelsiusPerKilocalorie
 #endif
             => ThermalResistance.FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterKelvinsPerWatt(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ThermalResistance.FromSquareCentimeterKelvinsPerWatt(double)" />
         public static ThermalResistance SquareCentimeterKelvinsPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static ThermalResistance SquareCentimeterKelvinsPerWatt<T>(this T value)
 #endif
             => ThermalResistance.FromSquareCentimeterKelvinsPerWatt(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(double)" />
         public static ThermalResistance SquareMeterDegreesCelsiusPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static ThermalResistance SquareMeterDegreesCelsiusPerWatt<T>(this T value
 #endif
             => ThermalResistance.FromSquareMeterDegreesCelsiusPerWatt(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareMeterKelvinsPerKilowatt(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ThermalResistance.FromSquareMeterKelvinsPerKilowatt(double)" />
         public static ThermalResistance SquareMeterKelvinsPerKilowatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static ThermalResistance SquareMeterKelvinsPerKilowatt<T>(this T value)
 #endif
             => ThermalResistance.FromSquareMeterKelvinsPerKilowatt(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="ThermalResistance.FromSquareMeterKelvinsPerWatt(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="ThermalResistance.FromSquareMeterKelvinsPerWatt(double)" />
         public static ThermalResistance SquareMeterKelvinsPerWatt<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
index 098becfff5..b3cee45718 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorqueExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToTorque
     /// </summary>
     public static class NumberToTorqueExtensions
     {
-        /// <inheritdoc cref="Torque.FromGramForceCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromGramForceCentimeters(double)" />
         public static Torque GramForceCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Torque GramForceCentimeters<T>(this T value)
 #endif
             => Torque.FromGramForceCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromGramForceMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromGramForceMeters(double)" />
         public static Torque GramForceMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Torque GramForceMeters<T>(this T value)
 #endif
             => Torque.FromGramForceMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromGramForceMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromGramForceMillimeters(double)" />
         public static Torque GramForceMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Torque GramForceMillimeters<T>(this T value)
 #endif
             => Torque.FromGramForceMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromKilogramForceCentimeters(double)" />
         public static Torque KilogramForceCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Torque KilogramForceCentimeters<T>(this T value)
 #endif
             => Torque.FromKilogramForceCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilogramForceMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromKilogramForceMeters(double)" />
         public static Torque KilogramForceMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Torque KilogramForceMeters<T>(this T value)
 #endif
             => Torque.FromKilogramForceMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromKilogramForceMillimeters(double)" />
         public static Torque KilogramForceMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Torque KilogramForceMillimeters<T>(this T value)
 #endif
             => Torque.FromKilogramForceMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromKilonewtonCentimeters(double)" />
         public static Torque KilonewtonCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Torque KilonewtonCentimeters<T>(this T value)
 #endif
             => Torque.FromKilonewtonCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilonewtonMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromKilonewtonMeters(double)" />
         public static Torque KilonewtonMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Torque KilonewtonMeters<T>(this T value)
 #endif
             => Torque.FromKilonewtonMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromKilonewtonMillimeters(double)" />
         public static Torque KilonewtonMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Torque KilonewtonMillimeters<T>(this T value)
 #endif
             => Torque.FromKilonewtonMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilopoundForceFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromKilopoundForceFeet(double)" />
         public static Torque KilopoundForceFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Torque KilopoundForceFeet<T>(this T value)
 #endif
             => Torque.FromKilopoundForceFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromKilopoundForceInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromKilopoundForceInches(double)" />
         public static Torque KilopoundForceInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Torque KilopoundForceInches<T>(this T value)
 #endif
             => Torque.FromKilopoundForceInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromMeganewtonCentimeters(double)" />
         public static Torque MeganewtonCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Torque MeganewtonCentimeters<T>(this T value)
 #endif
             => Torque.FromMeganewtonCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMeganewtonMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromMeganewtonMeters(double)" />
         public static Torque MeganewtonMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Torque MeganewtonMeters<T>(this T value)
 #endif
             => Torque.FromMeganewtonMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromMeganewtonMillimeters(double)" />
         public static Torque MeganewtonMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Torque MeganewtonMillimeters<T>(this T value)
 #endif
             => Torque.FromMeganewtonMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMegapoundForceFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromMegapoundForceFeet(double)" />
         public static Torque MegapoundForceFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Torque MegapoundForceFeet<T>(this T value)
 #endif
             => Torque.FromMegapoundForceFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromMegapoundForceInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromMegapoundForceInches(double)" />
         public static Torque MegapoundForceInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Torque MegapoundForceInches<T>(this T value)
 #endif
             => Torque.FromMegapoundForceInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromNewtonCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromNewtonCentimeters(double)" />
         public static Torque NewtonCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Torque NewtonCentimeters<T>(this T value)
 #endif
             => Torque.FromNewtonCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromNewtonMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromNewtonMeters(double)" />
         public static Torque NewtonMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Torque NewtonMeters<T>(this T value)
 #endif
             => Torque.FromNewtonMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromNewtonMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromNewtonMillimeters(double)" />
         public static Torque NewtonMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Torque NewtonMillimeters<T>(this T value)
 #endif
             => Torque.FromNewtonMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromPoundalFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromPoundalFeet(double)" />
         public static Torque PoundalFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Torque PoundalFeet<T>(this T value)
 #endif
             => Torque.FromPoundalFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromPoundForceFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromPoundForceFeet(double)" />
         public static Torque PoundForceFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Torque PoundForceFeet<T>(this T value)
 #endif
             => Torque.FromPoundForceFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromPoundForceInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromPoundForceInches(double)" />
         public static Torque PoundForceInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Torque PoundForceInches<T>(this T value)
 #endif
             => Torque.FromPoundForceInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromTonneForceCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromTonneForceCentimeters(double)" />
         public static Torque TonneForceCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Torque TonneForceCentimeters<T>(this T value)
 #endif
             => Torque.FromTonneForceCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromTonneForceMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromTonneForceMeters(double)" />
         public static Torque TonneForceMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Torque TonneForceMeters<T>(this T value)
 #endif
             => Torque.FromTonneForceMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Torque.FromTonneForceMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Torque.FromTonneForceMillimeters(double)" />
         public static Torque TonneForceMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
index feecde6375..c5d1cb1107 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTorquePerLengthExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToTorquePerLength
     /// </summary>
     public static class NumberToTorquePerLengthExtensions
     {
-        /// <inheritdoc cref="TorquePerLength.FromKilogramForceCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromKilogramForceCentimetersPerMeter(double)" />
         public static TorquePerLength KilogramForceCentimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static TorquePerLength KilogramForceCentimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromKilogramForceCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilogramForceMetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromKilogramForceMetersPerMeter(double)" />
         public static TorquePerLength KilogramForceMetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static TorquePerLength KilogramForceMetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromKilogramForceMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilogramForceMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromKilogramForceMillimetersPerMeter(double)" />
         public static TorquePerLength KilogramForceMillimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static TorquePerLength KilogramForceMillimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromKilogramForceMillimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilonewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromKilonewtonCentimetersPerMeter(double)" />
         public static TorquePerLength KilonewtonCentimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static TorquePerLength KilonewtonCentimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromKilonewtonCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilonewtonMetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromKilonewtonMetersPerMeter(double)" />
         public static TorquePerLength KilonewtonMetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static TorquePerLength KilonewtonMetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromKilonewtonMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilonewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromKilonewtonMillimetersPerMeter(double)" />
         public static TorquePerLength KilonewtonMillimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static TorquePerLength KilonewtonMillimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromKilonewtonMillimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilopoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromKilopoundForceFeetPerFoot(double)" />
         public static TorquePerLength KilopoundForceFeetPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static TorquePerLength KilopoundForceFeetPerFoot<T>(this T value)
 #endif
             => TorquePerLength.FromKilopoundForceFeetPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromKilopoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromKilopoundForceInchesPerFoot(double)" />
         public static TorquePerLength KilopoundForceInchesPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static TorquePerLength KilopoundForceInchesPerFoot<T>(this T value)
 #endif
             => TorquePerLength.FromKilopoundForceInchesPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMeganewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromMeganewtonCentimetersPerMeter(double)" />
         public static TorquePerLength MeganewtonCentimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static TorquePerLength MeganewtonCentimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromMeganewtonCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMeganewtonMetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromMeganewtonMetersPerMeter(double)" />
         public static TorquePerLength MeganewtonMetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static TorquePerLength MeganewtonMetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromMeganewtonMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMeganewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromMeganewtonMillimetersPerMeter(double)" />
         public static TorquePerLength MeganewtonMillimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static TorquePerLength MeganewtonMillimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromMeganewtonMillimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMegapoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromMegapoundForceFeetPerFoot(double)" />
         public static TorquePerLength MegapoundForceFeetPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static TorquePerLength MegapoundForceFeetPerFoot<T>(this T value)
 #endif
             => TorquePerLength.FromMegapoundForceFeetPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromMegapoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromMegapoundForceInchesPerFoot(double)" />
         public static TorquePerLength MegapoundForceInchesPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static TorquePerLength MegapoundForceInchesPerFoot<T>(this T value)
 #endif
             => TorquePerLength.FromMegapoundForceInchesPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromNewtonCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromNewtonCentimetersPerMeter(double)" />
         public static TorquePerLength NewtonCentimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static TorquePerLength NewtonCentimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromNewtonCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromNewtonMetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromNewtonMetersPerMeter(double)" />
         public static TorquePerLength NewtonMetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static TorquePerLength NewtonMetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromNewtonMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromNewtonMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromNewtonMillimetersPerMeter(double)" />
         public static TorquePerLength NewtonMillimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static TorquePerLength NewtonMillimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromNewtonMillimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromPoundForceFeetPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromPoundForceFeetPerFoot(double)" />
         public static TorquePerLength PoundForceFeetPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static TorquePerLength PoundForceFeetPerFoot<T>(this T value)
 #endif
             => TorquePerLength.FromPoundForceFeetPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromPoundForceInchesPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromPoundForceInchesPerFoot(double)" />
         public static TorquePerLength PoundForceInchesPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static TorquePerLength PoundForceInchesPerFoot<T>(this T value)
 #endif
             => TorquePerLength.FromPoundForceInchesPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromTonneForceCentimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromTonneForceCentimetersPerMeter(double)" />
         public static TorquePerLength TonneForceCentimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static TorquePerLength TonneForceCentimetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromTonneForceCentimetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromTonneForceMetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromTonneForceMetersPerMeter(double)" />
         public static TorquePerLength TonneForceMetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static TorquePerLength TonneForceMetersPerMeter<T>(this T value)
 #endif
             => TorquePerLength.FromTonneForceMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="TorquePerLength.FromTonneForceMillimetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="TorquePerLength.FromTonneForceMillimetersPerMeter(double)" />
         public static TorquePerLength TonneForceMillimetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
index 03d97b2d24..a5f16f99cc 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToTurbidityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToTurbidity
     /// </summary>
     public static class NumberToTurbidityExtensions
     {
-        /// <inheritdoc cref="Turbidity.FromNTU(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Turbidity.FromNTU(double)" />
         public static Turbidity NTU<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
index b46ea29956..ff518abba9 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVitaminAExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToVitaminA
     /// </summary>
     public static class NumberToVitaminAExtensions
     {
-        /// <inheritdoc cref="VitaminA.FromInternationalUnits(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VitaminA.FromInternationalUnits(double)" />
         public static VitaminA InternationalUnits<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
index 20c9d9e30c..d3faaab660 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeConcentrationExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToVolumeConcentration
     /// </summary>
     public static class NumberToVolumeConcentrationExtensions
     {
-        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerLiter(double)" />
         public static VolumeConcentration CentilitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static VolumeConcentration CentilitersPerLiter<T>(this T value)
 #endif
             => VolumeConcentration.FromCentilitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMililiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromCentilitersPerMililiter(double)" />
         public static VolumeConcentration CentilitersPerMililiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static VolumeConcentration CentilitersPerMililiter<T>(this T value)
 #endif
             => VolumeConcentration.FromCentilitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerLiter(double)" />
         public static VolumeConcentration DecilitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static VolumeConcentration DecilitersPerLiter<T>(this T value)
 #endif
             => VolumeConcentration.FromDecilitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMililiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromDecilitersPerMililiter(double)" />
         public static VolumeConcentration DecilitersPerMililiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static VolumeConcentration DecilitersPerMililiter<T>(this T value)
 #endif
             => VolumeConcentration.FromDecilitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromDecimalFractions(double)" />
         public static VolumeConcentration DecimalFractions<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static VolumeConcentration DecimalFractions<T>(this T value)
 #endif
             => VolumeConcentration.FromDecimalFractions(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromLitersPerLiter(double)" />
         public static VolumeConcentration LitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static VolumeConcentration LitersPerLiter<T>(this T value)
 #endif
             => VolumeConcentration.FromLitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromLitersPerMililiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromLitersPerMililiter(double)" />
         public static VolumeConcentration LitersPerMililiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static VolumeConcentration LitersPerMililiter<T>(this T value)
 #endif
             => VolumeConcentration.FromLitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerLiter(double)" />
         public static VolumeConcentration MicrolitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static VolumeConcentration MicrolitersPerLiter<T>(this T value)
 #endif
             => VolumeConcentration.FromMicrolitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMililiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromMicrolitersPerMililiter(double)" />
         public static VolumeConcentration MicrolitersPerMililiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static VolumeConcentration MicrolitersPerMililiter<T>(this T value)
 #endif
             => VolumeConcentration.FromMicrolitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerLiter(double)" />
         public static VolumeConcentration MillilitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static VolumeConcentration MillilitersPerLiter<T>(this T value)
 #endif
             => VolumeConcentration.FromMillilitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMililiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromMillilitersPerMililiter(double)" />
         public static VolumeConcentration MillilitersPerMililiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static VolumeConcentration MillilitersPerMililiter<T>(this T value)
 #endif
             => VolumeConcentration.FromMillilitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerLiter(double)" />
         public static VolumeConcentration NanolitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static VolumeConcentration NanolitersPerLiter<T>(this T value)
 #endif
             => VolumeConcentration.FromNanolitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMililiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromNanolitersPerMililiter(double)" />
         public static VolumeConcentration NanolitersPerMililiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static VolumeConcentration NanolitersPerMililiter<T>(this T value)
 #endif
             => VolumeConcentration.FromNanolitersPerMililiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerBillion(double)" />
         public static VolumeConcentration PartsPerBillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static VolumeConcentration PartsPerBillion<T>(this T value)
 #endif
             => VolumeConcentration.FromPartsPerBillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerMillion(double)" />
         public static VolumeConcentration PartsPerMillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static VolumeConcentration PartsPerMillion<T>(this T value)
 #endif
             => VolumeConcentration.FromPartsPerMillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerThousand(double)" />
         public static VolumeConcentration PartsPerThousand<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static VolumeConcentration PartsPerThousand<T>(this T value)
 #endif
             => VolumeConcentration.FromPartsPerThousand(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPartsPerTrillion(double)" />
         public static VolumeConcentration PartsPerTrillion<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static VolumeConcentration PartsPerTrillion<T>(this T value)
 #endif
             => VolumeConcentration.FromPartsPerTrillion(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPercent(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPercent(double)" />
         public static VolumeConcentration Percent<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static VolumeConcentration Percent<T>(this T value)
 #endif
             => VolumeConcentration.FromPercent(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerLiter(double)" />
         public static VolumeConcentration PicolitersPerLiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static VolumeConcentration PicolitersPerLiter<T>(this T value)
 #endif
             => VolumeConcentration.FromPicolitersPerLiter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMililiter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeConcentration.FromPicolitersPerMililiter(double)" />
         public static VolumeConcentration PicolitersPerMililiter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
index 11501f8015..c979f5644b 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToVolume
     /// </summary>
     public static class NumberToVolumeExtensions
     {
-        /// <inheritdoc cref="Volume.FromAcreFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromAcreFeet(double)" />
         public static Volume AcreFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static Volume AcreFeet<T>(this T value)
 #endif
             => Volume.FromAcreFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromAuTablespoons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromAuTablespoons(double)" />
         public static Volume AuTablespoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static Volume AuTablespoons<T>(this T value)
 #endif
             => Volume.FromAuTablespoons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromBoardFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromBoardFeet(double)" />
         public static Volume BoardFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static Volume BoardFeet<T>(this T value)
 #endif
             => Volume.FromBoardFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCentiliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCentiliters(double)" />
         public static Volume Centiliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static Volume Centiliters<T>(this T value)
 #endif
             => Volume.FromCentiliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicCentimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicCentimeters(double)" />
         public static Volume CubicCentimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static Volume CubicCentimeters<T>(this T value)
 #endif
             => Volume.FromCubicCentimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicDecimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicDecimeters(double)" />
         public static Volume CubicDecimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static Volume CubicDecimeters<T>(this T value)
 #endif
             => Volume.FromCubicDecimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicFeet(double)" />
         public static Volume CubicFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static Volume CubicFeet<T>(this T value)
 #endif
             => Volume.FromCubicFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicHectometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicHectometers(double)" />
         public static Volume CubicHectometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static Volume CubicHectometers<T>(this T value)
 #endif
             => Volume.FromCubicHectometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicInches(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicInches(double)" />
         public static Volume CubicInches<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static Volume CubicInches<T>(this T value)
 #endif
             => Volume.FromCubicInches(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicKilometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicKilometers(double)" />
         public static Volume CubicKilometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static Volume CubicKilometers<T>(this T value)
 #endif
             => Volume.FromCubicKilometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicMeters(double)" />
         public static Volume CubicMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static Volume CubicMeters<T>(this T value)
 #endif
             => Volume.FromCubicMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicMicrometers(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicMicrometers(double)" />
         public static Volume CubicMicrometers<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static Volume CubicMicrometers<T>(this T value)
 #endif
             => Volume.FromCubicMicrometers(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicMiles(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicMiles(double)" />
         public static Volume CubicMiles<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static Volume CubicMiles<T>(this T value)
 #endif
             => Volume.FromCubicMiles(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicMillimeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicMillimeters(double)" />
         public static Volume CubicMillimeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static Volume CubicMillimeters<T>(this T value)
 #endif
             => Volume.FromCubicMillimeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromCubicYards(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromCubicYards(double)" />
         public static Volume CubicYards<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static Volume CubicYards<T>(this T value)
 #endif
             => Volume.FromCubicYards(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromDecaliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromDecaliters(double)" />
         public static Volume Decaliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static Volume Decaliters<T>(this T value)
 #endif
             => Volume.FromDecaliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromDecausGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromDecausGallons(double)" />
         public static Volume DecausGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static Volume DecausGallons<T>(this T value)
 #endif
             => Volume.FromDecausGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromDeciliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromDeciliters(double)" />
         public static Volume Deciliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static Volume Deciliters<T>(this T value)
 #endif
             => Volume.FromDeciliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromDeciusGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromDeciusGallons(double)" />
         public static Volume DeciusGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static Volume DeciusGallons<T>(this T value)
 #endif
             => Volume.FromDeciusGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromHectocubicFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromHectocubicFeet(double)" />
         public static Volume HectocubicFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static Volume HectocubicFeet<T>(this T value)
 #endif
             => Volume.FromHectocubicFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromHectocubicMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromHectocubicMeters(double)" />
         public static Volume HectocubicMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static Volume HectocubicMeters<T>(this T value)
 #endif
             => Volume.FromHectocubicMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromHectoliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromHectoliters(double)" />
         public static Volume Hectoliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static Volume Hectoliters<T>(this T value)
 #endif
             => Volume.FromHectoliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromHectousGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromHectousGallons(double)" />
         public static Volume HectousGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static Volume HectousGallons<T>(this T value)
 #endif
             => Volume.FromHectousGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialBeerBarrels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromImperialBeerBarrels(double)" />
         public static Volume ImperialBeerBarrels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static Volume ImperialBeerBarrels<T>(this T value)
 #endif
             => Volume.FromImperialBeerBarrels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromImperialGallons(double)" />
         public static Volume ImperialGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static Volume ImperialGallons<T>(this T value)
 #endif
             => Volume.FromImperialGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialOunces(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromImperialOunces(double)" />
         public static Volume ImperialOunces<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static Volume ImperialOunces<T>(this T value)
 #endif
             => Volume.FromImperialOunces(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialPints(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromImperialPints(double)" />
         public static Volume ImperialPints<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static Volume ImperialPints<T>(this T value)
 #endif
             => Volume.FromImperialPints(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromImperialQuarts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromImperialQuarts(double)" />
         public static Volume ImperialQuarts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static Volume ImperialQuarts<T>(this T value)
 #endif
             => Volume.FromImperialQuarts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKilocubicFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromKilocubicFeet(double)" />
         public static Volume KilocubicFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static Volume KilocubicFeet<T>(this T value)
 #endif
             => Volume.FromKilocubicFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKilocubicMeters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromKilocubicMeters(double)" />
         public static Volume KilocubicMeters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static Volume KilocubicMeters<T>(this T value)
 #endif
             => Volume.FromKilocubicMeters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKiloimperialGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromKiloimperialGallons(double)" />
         public static Volume KiloimperialGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static Volume KiloimperialGallons<T>(this T value)
 #endif
             => Volume.FromKiloimperialGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKiloliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromKiloliters(double)" />
         public static Volume Kiloliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static Volume Kiloliters<T>(this T value)
 #endif
             => Volume.FromKiloliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromKilousGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromKilousGallons(double)" />
         public static Volume KilousGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static Volume KilousGallons<T>(this T value)
 #endif
             => Volume.FromKilousGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromLiters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromLiters(double)" />
         public static Volume Liters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static Volume Liters<T>(this T value)
 #endif
             => Volume.FromLiters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMegacubicFeet(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromMegacubicFeet(double)" />
         public static Volume MegacubicFeet<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static Volume MegacubicFeet<T>(this T value)
 #endif
             => Volume.FromMegacubicFeet(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMegaimperialGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromMegaimperialGallons(double)" />
         public static Volume MegaimperialGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static Volume MegaimperialGallons<T>(this T value)
 #endif
             => Volume.FromMegaimperialGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMegaliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromMegaliters(double)" />
         public static Volume Megaliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static Volume Megaliters<T>(this T value)
 #endif
             => Volume.FromMegaliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMegausGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromMegausGallons(double)" />
         public static Volume MegausGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -336,7 +336,7 @@ public static Volume MegausGallons<T>(this T value)
 #endif
             => Volume.FromMegausGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMetricCups(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromMetricCups(double)" />
         public static Volume MetricCups<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -344,7 +344,7 @@ public static Volume MetricCups<T>(this T value)
 #endif
             => Volume.FromMetricCups(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMetricTeaspoons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromMetricTeaspoons(double)" />
         public static Volume MetricTeaspoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -352,7 +352,7 @@ public static Volume MetricTeaspoons<T>(this T value)
 #endif
             => Volume.FromMetricTeaspoons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMicroliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromMicroliters(double)" />
         public static Volume Microliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -360,7 +360,7 @@ public static Volume Microliters<T>(this T value)
 #endif
             => Volume.FromMicroliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromMilliliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromMilliliters(double)" />
         public static Volume Milliliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -368,7 +368,7 @@ public static Volume Milliliters<T>(this T value)
 #endif
             => Volume.FromMilliliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromNanoliters(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromNanoliters(double)" />
         public static Volume Nanoliters<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -376,7 +376,7 @@ public static Volume Nanoliters<T>(this T value)
 #endif
             => Volume.FromNanoliters(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromOilBarrels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromOilBarrels(double)" />
         public static Volume OilBarrels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -384,7 +384,7 @@ public static Volume OilBarrels<T>(this T value)
 #endif
             => Volume.FromOilBarrels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUkTablespoons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUkTablespoons(double)" />
         public static Volume UkTablespoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -392,7 +392,7 @@ public static Volume UkTablespoons<T>(this T value)
 #endif
             => Volume.FromUkTablespoons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsBeerBarrels(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsBeerBarrels(double)" />
         public static Volume UsBeerBarrels<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -400,7 +400,7 @@ public static Volume UsBeerBarrels<T>(this T value)
 #endif
             => Volume.FromUsBeerBarrels(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsCustomaryCups(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsCustomaryCups(double)" />
         public static Volume UsCustomaryCups<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -408,7 +408,7 @@ public static Volume UsCustomaryCups<T>(this T value)
 #endif
             => Volume.FromUsCustomaryCups(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsGallons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsGallons(double)" />
         public static Volume UsGallons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -416,7 +416,7 @@ public static Volume UsGallons<T>(this T value)
 #endif
             => Volume.FromUsGallons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsLegalCups(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsLegalCups(double)" />
         public static Volume UsLegalCups<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -424,7 +424,7 @@ public static Volume UsLegalCups<T>(this T value)
 #endif
             => Volume.FromUsLegalCups(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsOunces(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsOunces(double)" />
         public static Volume UsOunces<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -432,7 +432,7 @@ public static Volume UsOunces<T>(this T value)
 #endif
             => Volume.FromUsOunces(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsPints(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsPints(double)" />
         public static Volume UsPints<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -440,7 +440,7 @@ public static Volume UsPints<T>(this T value)
 #endif
             => Volume.FromUsPints(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsQuarts(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsQuarts(double)" />
         public static Volume UsQuarts<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -448,7 +448,7 @@ public static Volume UsQuarts<T>(this T value)
 #endif
             => Volume.FromUsQuarts(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsTablespoons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsTablespoons(double)" />
         public static Volume UsTablespoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -456,7 +456,7 @@ public static Volume UsTablespoons<T>(this T value)
 #endif
             => Volume.FromUsTablespoons(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Volume.FromUsTeaspoons(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="Volume.FromUsTeaspoons(double)" />
         public static Volume UsTeaspoons<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
index 4542ca2890..0640c22d9f 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToVolumeFlow
     /// </summary>
     public static class NumberToVolumeFlowExtensions
     {
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerDay(double)" />
         public static VolumeFlow AcreFeetPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static VolumeFlow AcreFeetPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromAcreFeetPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerHour(double)" />
         public static VolumeFlow AcreFeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static VolumeFlow AcreFeetPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromAcreFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerMinute(double)" />
         public static VolumeFlow AcreFeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static VolumeFlow AcreFeetPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromAcreFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromAcreFeetPerSecond(double)" />
         public static VolumeFlow AcreFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static VolumeFlow AcreFeetPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromAcreFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerDay(double)" />
         public static VolumeFlow CentilitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static VolumeFlow CentilitersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromCentilitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerHour(double)" />
         public static VolumeFlow CentilitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static VolumeFlow CentilitersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromCentilitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerMinute(double)" />
         public static VolumeFlow CentilitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static VolumeFlow CentilitersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromCentilitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCentilitersPerSecond(double)" />
         public static VolumeFlow CentilitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static VolumeFlow CentilitersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromCentilitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicCentimetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicCentimetersPerMinute(double)" />
         public static VolumeFlow CubicCentimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -104,7 +104,7 @@ public static VolumeFlow CubicCentimetersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromCubicCentimetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicDecimetersPerMinute(double)" />
         public static VolumeFlow CubicDecimetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -112,7 +112,7 @@ public static VolumeFlow CubicDecimetersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromCubicDecimetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerHour(double)" />
         public static VolumeFlow CubicFeetPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -120,7 +120,7 @@ public static VolumeFlow CubicFeetPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromCubicFeetPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerMinute(double)" />
         public static VolumeFlow CubicFeetPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -128,7 +128,7 @@ public static VolumeFlow CubicFeetPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromCubicFeetPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicFeetPerSecond(double)" />
         public static VolumeFlow CubicFeetPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -136,7 +136,7 @@ public static VolumeFlow CubicFeetPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromCubicFeetPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerDay(double)" />
         public static VolumeFlow CubicMetersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -144,7 +144,7 @@ public static VolumeFlow CubicMetersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromCubicMetersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerHour(double)" />
         public static VolumeFlow CubicMetersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -152,7 +152,7 @@ public static VolumeFlow CubicMetersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromCubicMetersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerMinute(double)" />
         public static VolumeFlow CubicMetersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -160,7 +160,7 @@ public static VolumeFlow CubicMetersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromCubicMetersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMetersPerSecond(double)" />
         public static VolumeFlow CubicMetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -168,7 +168,7 @@ public static VolumeFlow CubicMetersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromCubicMetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicMillimetersPerSecond(double)" />
         public static VolumeFlow CubicMillimetersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -176,7 +176,7 @@ public static VolumeFlow CubicMillimetersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromCubicMillimetersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerDay(double)" />
         public static VolumeFlow CubicYardsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -184,7 +184,7 @@ public static VolumeFlow CubicYardsPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromCubicYardsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerHour(double)" />
         public static VolumeFlow CubicYardsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -192,7 +192,7 @@ public static VolumeFlow CubicYardsPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromCubicYardsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerMinute(double)" />
         public static VolumeFlow CubicYardsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -200,7 +200,7 @@ public static VolumeFlow CubicYardsPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromCubicYardsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromCubicYardsPerSecond(double)" />
         public static VolumeFlow CubicYardsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -208,7 +208,7 @@ public static VolumeFlow CubicYardsPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromCubicYardsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerDay(double)" />
         public static VolumeFlow DecilitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -216,7 +216,7 @@ public static VolumeFlow DecilitersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromDecilitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerHour(double)" />
         public static VolumeFlow DecilitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -224,7 +224,7 @@ public static VolumeFlow DecilitersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromDecilitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerMinute(double)" />
         public static VolumeFlow DecilitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -232,7 +232,7 @@ public static VolumeFlow DecilitersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromDecilitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromDecilitersPerSecond(double)" />
         public static VolumeFlow DecilitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -240,7 +240,7 @@ public static VolumeFlow DecilitersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromDecilitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerDay(double)" />
         public static VolumeFlow KilolitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -248,7 +248,7 @@ public static VolumeFlow KilolitersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromKilolitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerHour(double)" />
         public static VolumeFlow KilolitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -256,7 +256,7 @@ public static VolumeFlow KilolitersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromKilolitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerMinute(double)" />
         public static VolumeFlow KilolitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -264,7 +264,7 @@ public static VolumeFlow KilolitersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromKilolitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilolitersPerSecond(double)" />
         public static VolumeFlow KilolitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -272,7 +272,7 @@ public static VolumeFlow KilolitersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromKilolitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromKilousGallonsPerMinute(double)" />
         public static VolumeFlow KilousGallonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -280,7 +280,7 @@ public static VolumeFlow KilousGallonsPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromKilousGallonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerDay(double)" />
         public static VolumeFlow LitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -288,7 +288,7 @@ public static VolumeFlow LitersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromLitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerHour(double)" />
         public static VolumeFlow LitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -296,7 +296,7 @@ public static VolumeFlow LitersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromLitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerMinute(double)" />
         public static VolumeFlow LitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -304,7 +304,7 @@ public static VolumeFlow LitersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromLitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromLitersPerSecond(double)" />
         public static VolumeFlow LitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -312,7 +312,7 @@ public static VolumeFlow LitersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromLitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerDay(double)" />
         public static VolumeFlow MegalitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -320,7 +320,7 @@ public static VolumeFlow MegalitersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromMegalitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerHour(double)" />
         public static VolumeFlow MegalitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -328,7 +328,7 @@ public static VolumeFlow MegalitersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromMegalitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerMinute(double)" />
         public static VolumeFlow MegalitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -336,7 +336,7 @@ public static VolumeFlow MegalitersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromMegalitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegalitersPerSecond(double)" />
         public static VolumeFlow MegalitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -344,7 +344,7 @@ public static VolumeFlow MegalitersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromMegalitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerDay(double)" />
         public static VolumeFlow MegaukGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -352,7 +352,7 @@ public static VolumeFlow MegaukGallonsPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromMegaukGallonsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegaukGallonsPerSecond(double)" />
         public static VolumeFlow MegaukGallonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -360,7 +360,7 @@ public static VolumeFlow MegaukGallonsPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromMegaukGallonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMegausGallonsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMegausGallonsPerDay(double)" />
         public static VolumeFlow MegausGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -368,7 +368,7 @@ public static VolumeFlow MegausGallonsPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromMegausGallonsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerDay(double)" />
         public static VolumeFlow MicrolitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -376,7 +376,7 @@ public static VolumeFlow MicrolitersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromMicrolitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerHour(double)" />
         public static VolumeFlow MicrolitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -384,7 +384,7 @@ public static VolumeFlow MicrolitersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromMicrolitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerMinute(double)" />
         public static VolumeFlow MicrolitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -392,7 +392,7 @@ public static VolumeFlow MicrolitersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromMicrolitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMicrolitersPerSecond(double)" />
         public static VolumeFlow MicrolitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -400,7 +400,7 @@ public static VolumeFlow MicrolitersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromMicrolitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerDay(double)" />
         public static VolumeFlow MillilitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -408,7 +408,7 @@ public static VolumeFlow MillilitersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromMillilitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerHour(double)" />
         public static VolumeFlow MillilitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -416,7 +416,7 @@ public static VolumeFlow MillilitersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromMillilitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerMinute(double)" />
         public static VolumeFlow MillilitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -424,7 +424,7 @@ public static VolumeFlow MillilitersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromMillilitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillilitersPerSecond(double)" />
         public static VolumeFlow MillilitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -432,7 +432,7 @@ public static VolumeFlow MillilitersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromMillilitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromMillionUsGallonsPerDay(double)" />
         public static VolumeFlow MillionUsGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -440,7 +440,7 @@ public static VolumeFlow MillionUsGallonsPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromMillionUsGallonsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerDay(double)" />
         public static VolumeFlow NanolitersPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -448,7 +448,7 @@ public static VolumeFlow NanolitersPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromNanolitersPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerHour(double)" />
         public static VolumeFlow NanolitersPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -456,7 +456,7 @@ public static VolumeFlow NanolitersPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromNanolitersPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerMinute(double)" />
         public static VolumeFlow NanolitersPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -464,7 +464,7 @@ public static VolumeFlow NanolitersPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromNanolitersPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromNanolitersPerSecond(double)" />
         public static VolumeFlow NanolitersPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -472,7 +472,7 @@ public static VolumeFlow NanolitersPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromNanolitersPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerDay(double)" />
         public static VolumeFlow OilBarrelsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -480,7 +480,7 @@ public static VolumeFlow OilBarrelsPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromOilBarrelsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerHour(double)" />
         public static VolumeFlow OilBarrelsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -488,7 +488,7 @@ public static VolumeFlow OilBarrelsPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromOilBarrelsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerMinute(double)" />
         public static VolumeFlow OilBarrelsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -496,7 +496,7 @@ public static VolumeFlow OilBarrelsPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromOilBarrelsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromOilBarrelsPerSecond(double)" />
         public static VolumeFlow OilBarrelsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -504,7 +504,7 @@ public static VolumeFlow OilBarrelsPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromOilBarrelsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerDay(double)" />
         public static VolumeFlow UkGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -512,7 +512,7 @@ public static VolumeFlow UkGallonsPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromUkGallonsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerHour(double)" />
         public static VolumeFlow UkGallonsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -520,7 +520,7 @@ public static VolumeFlow UkGallonsPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromUkGallonsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerMinute(double)" />
         public static VolumeFlow UkGallonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -528,7 +528,7 @@ public static VolumeFlow UkGallonsPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromUkGallonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromUkGallonsPerSecond(double)" />
         public static VolumeFlow UkGallonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -536,7 +536,7 @@ public static VolumeFlow UkGallonsPerSecond<T>(this T value)
 #endif
             => VolumeFlow.FromUkGallonsPerSecond(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerDay(double)" />
         public static VolumeFlow UsGallonsPerDay<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -544,7 +544,7 @@ public static VolumeFlow UsGallonsPerDay<T>(this T value)
 #endif
             => VolumeFlow.FromUsGallonsPerDay(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerHour(double)" />
         public static VolumeFlow UsGallonsPerHour<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -552,7 +552,7 @@ public static VolumeFlow UsGallonsPerHour<T>(this T value)
 #endif
             => VolumeFlow.FromUsGallonsPerHour(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerMinute(double)" />
         public static VolumeFlow UsGallonsPerMinute<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -560,7 +560,7 @@ public static VolumeFlow UsGallonsPerMinute<T>(this T value)
 #endif
             => VolumeFlow.FromUsGallonsPerMinute(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlow.FromUsGallonsPerSecond(double)" />
         public static VolumeFlow UsGallonsPerSecond<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
index baeb644a4d..a51f32978a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumeFlowPerAreaExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToVolumeFlowPerArea
     /// </summary>
     public static class NumberToVolumeFlowPerAreaExtensions
     {
-        /// <inheritdoc cref="VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(double)" />
         public static VolumeFlowPerArea CubicFeetPerMinutePerSquareFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static VolumeFlowPerArea CubicFeetPerMinutePerSquareFoot<T>(this T value)
 #endif
             => VolumeFlowPerArea.FromCubicFeetPerMinutePerSquareFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumeFlowPerArea.FromCubicMetersPerSecondPerSquareMeter(double)" />
         public static VolumeFlowPerArea CubicMetersPerSecondPerSquareMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
index 39ee688498..c464b0668a 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumePerLengthExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToVolumePerLength
     /// </summary>
     public static class NumberToVolumePerLengthExtensions
     {
-        /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromCubicMetersPerMeter(double)" />
         public static VolumePerLength CubicMetersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static VolumePerLength CubicMetersPerMeter<T>(this T value)
 #endif
             => VolumePerLength.FromCubicMetersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerFoot(double)" />
         public static VolumePerLength CubicYardsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static VolumePerLength CubicYardsPerFoot<T>(this T value)
 #endif
             => VolumePerLength.FromCubicYardsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromCubicYardsPerUsSurveyFoot(double)" />
         public static VolumePerLength CubicYardsPerUsSurveyFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static VolumePerLength CubicYardsPerUsSurveyFoot<T>(this T value)
 #endif
             => VolumePerLength.FromCubicYardsPerUsSurveyFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromImperialGallonsPerMile(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromImperialGallonsPerMile(double)" />
         public static VolumePerLength ImperialGallonsPerMile<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static VolumePerLength ImperialGallonsPerMile<T>(this T value)
 #endif
             => VolumePerLength.FromImperialGallonsPerMile(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerKilometer(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromLitersPerKilometer(double)" />
         public static VolumePerLength LitersPerKilometer<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static VolumePerLength LitersPerKilometer<T>(this T value)
 #endif
             => VolumePerLength.FromLitersPerKilometer(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromLitersPerMeter(double)" />
         public static VolumePerLength LitersPerMeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static VolumePerLength LitersPerMeter<T>(this T value)
 #endif
             => VolumePerLength.FromLitersPerMeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromLitersPerMillimeter(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromLitersPerMillimeter(double)" />
         public static VolumePerLength LitersPerMillimeter<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static VolumePerLength LitersPerMillimeter<T>(this T value)
 #endif
             => VolumePerLength.FromLitersPerMillimeter(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromOilBarrelsPerFoot(double)" />
         public static VolumePerLength OilBarrelsPerFoot<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static VolumePerLength OilBarrelsPerFoot<T>(this T value)
 #endif
             => VolumePerLength.FromOilBarrelsPerFoot(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumePerLength.FromUsGallonsPerMile(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumePerLength.FromUsGallonsPerMile(double)" />
         public static VolumePerLength UsGallonsPerMile<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
index 1ca2f92b3f..14f3017903 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToVolumetricHeatCapacityExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToVolumetricHeatCapacity
     /// </summary>
     public static class NumberToVolumetricHeatCapacityExtensions
     {
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(double)" />
         public static VolumetricHeatCapacity BtusPerCubicFootDegreeFahrenheit<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static VolumetricHeatCapacity BtusPerCubicFootDegreeFahrenheit<T>(this T
 #endif
             => VolumetricHeatCapacity.FromBtusPerCubicFootDegreeFahrenheit(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(double)" />
         public static VolumetricHeatCapacity CaloriesPerCubicCentimeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static VolumetricHeatCapacity CaloriesPerCubicCentimeterDegreeCelsius<T>(
 #endif
             => VolumetricHeatCapacity.FromCaloriesPerCubicCentimeterDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(double)" />
         public static VolumetricHeatCapacity JoulesPerCubicMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static VolumetricHeatCapacity JoulesPerCubicMeterDegreeCelsius<T>(this T
 #endif
             => VolumetricHeatCapacity.FromJoulesPerCubicMeterDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(double)" />
         public static VolumetricHeatCapacity JoulesPerCubicMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static VolumetricHeatCapacity JoulesPerCubicMeterKelvin<T>(this T value)
 #endif
             => VolumetricHeatCapacity.FromJoulesPerCubicMeterKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(double)" />
         public static VolumetricHeatCapacity KilocaloriesPerCubicCentimeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static VolumetricHeatCapacity KilocaloriesPerCubicCentimeterDegreeCelsius
 #endif
             => VolumetricHeatCapacity.FromKilocaloriesPerCubicCentimeterDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(double)" />
         public static VolumetricHeatCapacity KilojoulesPerCubicMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -80,7 +80,7 @@ public static VolumetricHeatCapacity KilojoulesPerCubicMeterDegreeCelsius<T>(thi
 #endif
             => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(double)" />
         public static VolumetricHeatCapacity KilojoulesPerCubicMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -88,7 +88,7 @@ public static VolumetricHeatCapacity KilojoulesPerCubicMeterKelvin<T>(this T val
 #endif
             => VolumetricHeatCapacity.FromKilojoulesPerCubicMeterKelvin(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(double)" />
         public static VolumetricHeatCapacity MegajoulesPerCubicMeterDegreeCelsius<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -96,7 +96,7 @@ public static VolumetricHeatCapacity MegajoulesPerCubicMeterDegreeCelsius<T>(thi
 #endif
             => VolumetricHeatCapacity.FromMegajoulesPerCubicMeterDegreeCelsius(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="VolumetricHeatCapacity.FromMegajoulesPerCubicMeterKelvin(double)" />
         public static VolumetricHeatCapacity MegajoulesPerCubicMeterKelvin<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
index 8be95727fb..7979daed07 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToWarpingMomentOfInertiaExtensions.g.cs
@@ -32,7 +32,7 @@ namespace UnitsNet.NumberExtensions.NumberToWarpingMomentOfInertia
     /// </summary>
     public static class NumberToWarpingMomentOfInertiaExtensions
     {
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromCentimetersToTheSixth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromCentimetersToTheSixth(double)" />
         public static WarpingMomentOfInertia CentimetersToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -40,7 +40,7 @@ public static WarpingMomentOfInertia CentimetersToTheSixth<T>(this T value)
 #endif
             => WarpingMomentOfInertia.FromCentimetersToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromDecimetersToTheSixth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromDecimetersToTheSixth(double)" />
         public static WarpingMomentOfInertia DecimetersToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -48,7 +48,7 @@ public static WarpingMomentOfInertia DecimetersToTheSixth<T>(this T value)
 #endif
             => WarpingMomentOfInertia.FromDecimetersToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromFeetToTheSixth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromFeetToTheSixth(double)" />
         public static WarpingMomentOfInertia FeetToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -56,7 +56,7 @@ public static WarpingMomentOfInertia FeetToTheSixth<T>(this T value)
 #endif
             => WarpingMomentOfInertia.FromFeetToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromInchesToTheSixth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromInchesToTheSixth(double)" />
         public static WarpingMomentOfInertia InchesToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -64,7 +64,7 @@ public static WarpingMomentOfInertia InchesToTheSixth<T>(this T value)
 #endif
             => WarpingMomentOfInertia.FromInchesToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromMetersToTheSixth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromMetersToTheSixth(double)" />
         public static WarpingMomentOfInertia MetersToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
@@ -72,7 +72,7 @@ public static WarpingMomentOfInertia MetersToTheSixth<T>(this T value)
 #endif
             => WarpingMomentOfInertia.FromMetersToTheSixth(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="WarpingMomentOfInertia.FromMillimetersToTheSixth(UnitsNet.QuantityValue)" />
+        /// <inheritdoc cref="WarpingMomentOfInertia.FromMillimetersToTheSixth(double)" />
         public static WarpingMomentOfInertia MillimetersToTheSixth<T>(this T value)
             where T : notnull
 #if NET7_0_OR_GREATER
diff --git a/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs b/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
index da5528afdc..cd1a5e3dc8 100644
--- a/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct AbsorbedDoseOfIonizingRadiation :
-        IArithmeticQuantity<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit, double>,
+        IArithmeticQuantity<AbsorbedDoseOfIonizingRadiation, AbsorbedDoseOfIonizingRadiationUnit>,
         IComparable,
         IComparable<AbsorbedDoseOfIonizingRadiation>,
         IConvertible,
@@ -165,7 +165,7 @@ public AbsorbedDoseOfIonizingRadiation(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -344,160 +344,144 @@ public static string GetAbbreviation(AbsorbedDoseOfIonizingRadiationUnit unit, I
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Centigray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromCentigrays(QuantityValue centigrays)
+        public static AbsorbedDoseOfIonizingRadiation FromCentigrays(double centigrays)
         {
-            double value = (double) centigrays;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Centigray);
+            return new AbsorbedDoseOfIonizingRadiation(centigrays, AbsorbedDoseOfIonizingRadiationUnit.Centigray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Femtogray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromFemtograys(QuantityValue femtograys)
+        public static AbsorbedDoseOfIonizingRadiation FromFemtograys(double femtograys)
         {
-            double value = (double) femtograys;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
+            return new AbsorbedDoseOfIonizingRadiation(femtograys, AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gigagray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromGigagrays(QuantityValue gigagrays)
+        public static AbsorbedDoseOfIonizingRadiation FromGigagrays(double gigagrays)
         {
-            double value = (double) gigagrays;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
+            return new AbsorbedDoseOfIonizingRadiation(gigagrays, AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromGrays(QuantityValue grays)
+        public static AbsorbedDoseOfIonizingRadiation FromGrays(double grays)
         {
-            double value = (double) grays;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Gray);
+            return new AbsorbedDoseOfIonizingRadiation(grays, AbsorbedDoseOfIonizingRadiationUnit.Gray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilogray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromKilograys(QuantityValue kilograys)
+        public static AbsorbedDoseOfIonizingRadiation FromKilograys(double kilograys)
         {
-            double value = (double) kilograys;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
+            return new AbsorbedDoseOfIonizingRadiation(kilograys, AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilorad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromKilorads(QuantityValue kilorads)
+        public static AbsorbedDoseOfIonizingRadiation FromKilorads(double kilorads)
         {
-            double value = (double) kilorads;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
+            return new AbsorbedDoseOfIonizingRadiation(kilorads, AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megagray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMegagrays(QuantityValue megagrays)
+        public static AbsorbedDoseOfIonizingRadiation FromMegagrays(double megagrays)
         {
-            double value = (double) megagrays;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Megagray);
+            return new AbsorbedDoseOfIonizingRadiation(megagrays, AbsorbedDoseOfIonizingRadiationUnit.Megagray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMegarads(QuantityValue megarads)
+        public static AbsorbedDoseOfIonizingRadiation FromMegarads(double megarads)
         {
-            double value = (double) megarads;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Megarad);
+            return new AbsorbedDoseOfIonizingRadiation(megarads, AbsorbedDoseOfIonizingRadiationUnit.Megarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Microgray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMicrograys(QuantityValue micrograys)
+        public static AbsorbedDoseOfIonizingRadiation FromMicrograys(double micrograys)
         {
-            double value = (double) micrograys;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Microgray);
+            return new AbsorbedDoseOfIonizingRadiation(micrograys, AbsorbedDoseOfIonizingRadiationUnit.Microgray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Milligray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMilligrays(QuantityValue milligrays)
+        public static AbsorbedDoseOfIonizingRadiation FromMilligrays(double milligrays)
         {
-            double value = (double) milligrays;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Milligray);
+            return new AbsorbedDoseOfIonizingRadiation(milligrays, AbsorbedDoseOfIonizingRadiationUnit.Milligray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Millirad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMillirads(QuantityValue millirads)
+        public static AbsorbedDoseOfIonizingRadiation FromMillirads(double millirads)
         {
-            double value = (double) millirads;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Millirad);
+            return new AbsorbedDoseOfIonizingRadiation(millirads, AbsorbedDoseOfIonizingRadiationUnit.Millirad);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Nanogray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromNanograys(QuantityValue nanograys)
+        public static AbsorbedDoseOfIonizingRadiation FromNanograys(double nanograys)
         {
-            double value = (double) nanograys;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
+            return new AbsorbedDoseOfIonizingRadiation(nanograys, AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Petagray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromPetagrays(QuantityValue petagrays)
+        public static AbsorbedDoseOfIonizingRadiation FromPetagrays(double petagrays)
         {
-            double value = (double) petagrays;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Petagray);
+            return new AbsorbedDoseOfIonizingRadiation(petagrays, AbsorbedDoseOfIonizingRadiationUnit.Petagray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Picogray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromPicograys(QuantityValue picograys)
+        public static AbsorbedDoseOfIonizingRadiation FromPicograys(double picograys)
         {
-            double value = (double) picograys;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Picogray);
+            return new AbsorbedDoseOfIonizingRadiation(picograys, AbsorbedDoseOfIonizingRadiationUnit.Picogray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Rad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromRads(QuantityValue rads)
+        public static AbsorbedDoseOfIonizingRadiation FromRads(double rads)
         {
-            double value = (double) rads;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Rad);
+            return new AbsorbedDoseOfIonizingRadiation(rads, AbsorbedDoseOfIonizingRadiationUnit.Rad);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Teragray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromTeragrays(QuantityValue teragrays)
+        public static AbsorbedDoseOfIonizingRadiation FromTeragrays(double teragrays)
         {
-            double value = (double) teragrays;
-            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Teragray);
+            return new AbsorbedDoseOfIonizingRadiation(teragrays, AbsorbedDoseOfIonizingRadiationUnit.Teragray);
         }
 
         /// <summary>
@@ -506,9 +490,9 @@ public static AbsorbedDoseOfIonizingRadiation FromTeragrays(QuantityValue teragr
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AbsorbedDoseOfIonizingRadiation unit value.</returns>
-        public static AbsorbedDoseOfIonizingRadiation From(QuantityValue value, AbsorbedDoseOfIonizingRadiationUnit fromUnit)
+        public static AbsorbedDoseOfIonizingRadiation From(double value, AbsorbedDoseOfIonizingRadiationUnit fromUnit)
         {
-            return new AbsorbedDoseOfIonizingRadiation((double)value, fromUnit);
+            return new AbsorbedDoseOfIonizingRadiation(value, fromUnit);
         }
 
         #endregion
@@ -919,15 +903,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is AbsorbedDoseOfIonizingRadiationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AbsorbedDoseOfIonizingRadiationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is AbsorbedDoseOfIonizingRadiationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AbsorbedDoseOfIonizingRadiationUnit)} is supported.", nameof(unit));
@@ -1072,18 +1047,6 @@ public AbsorbedDoseOfIonizingRadiation ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AbsorbedDoseOfIonizingRadiationUnit> IQuantity<AbsorbedDoseOfIonizingRadiationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not AbsorbedDoseOfIonizingRadiationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AbsorbedDoseOfIonizingRadiationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
index 72ac25caa1..7c0dda39bc 100644
--- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Acceleration :
-        IArithmeticQuantity<Acceleration, AccelerationUnit, double>,
+        IArithmeticQuantity<Acceleration, AccelerationUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Acceleration, Mass, Force>,
         IDivisionOperators<Acceleration, Duration, Jerk>,
@@ -171,7 +171,7 @@ public Acceleration(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -336,140 +336,126 @@ public static string GetAbbreviation(AccelerationUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.CentimeterPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromCentimetersPerSecondSquared(QuantityValue centimeterspersecondsquared)
+        public static Acceleration FromCentimetersPerSecondSquared(double centimeterspersecondsquared)
         {
-            double value = (double) centimeterspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared);
+            return new Acceleration(centimeterspersecondsquared, AccelerationUnit.CentimeterPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.DecimeterPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromDecimetersPerSecondSquared(QuantityValue decimeterspersecondsquared)
+        public static Acceleration FromDecimetersPerSecondSquared(double decimeterspersecondsquared)
         {
-            double value = (double) decimeterspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared);
+            return new Acceleration(decimeterspersecondsquared, AccelerationUnit.DecimeterPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.FootPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromFeetPerSecondSquared(QuantityValue feetpersecondsquared)
+        public static Acceleration FromFeetPerSecondSquared(double feetpersecondsquared)
         {
-            double value = (double) feetpersecondsquared;
-            return new Acceleration(value, AccelerationUnit.FootPerSecondSquared);
+            return new Acceleration(feetpersecondsquared, AccelerationUnit.FootPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.InchPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromInchesPerSecondSquared(QuantityValue inchespersecondsquared)
+        public static Acceleration FromInchesPerSecondSquared(double inchespersecondsquared)
         {
-            double value = (double) inchespersecondsquared;
-            return new Acceleration(value, AccelerationUnit.InchPerSecondSquared);
+            return new Acceleration(inchespersecondsquared, AccelerationUnit.InchPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KilometerPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKilometersPerSecondSquared(QuantityValue kilometerspersecondsquared)
+        public static Acceleration FromKilometersPerSecondSquared(double kilometerspersecondsquared)
         {
-            double value = (double) kilometerspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared);
+            return new Acceleration(kilometerspersecondsquared, AccelerationUnit.KilometerPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerHour(QuantityValue knotsperhour)
+        public static Acceleration FromKnotsPerHour(double knotsperhour)
         {
-            double value = (double) knotsperhour;
-            return new Acceleration(value, AccelerationUnit.KnotPerHour);
+            return new Acceleration(knotsperhour, AccelerationUnit.KnotPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerMinute(QuantityValue knotsperminute)
+        public static Acceleration FromKnotsPerMinute(double knotsperminute)
         {
-            double value = (double) knotsperminute;
-            return new Acceleration(value, AccelerationUnit.KnotPerMinute);
+            return new Acceleration(knotsperminute, AccelerationUnit.KnotPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerSecond(QuantityValue knotspersecond)
+        public static Acceleration FromKnotsPerSecond(double knotspersecond)
         {
-            double value = (double) knotspersecond;
-            return new Acceleration(value, AccelerationUnit.KnotPerSecond);
+            return new Acceleration(knotspersecond, AccelerationUnit.KnotPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MeterPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMetersPerSecondSquared(QuantityValue meterspersecondsquared)
+        public static Acceleration FromMetersPerSecondSquared(double meterspersecondsquared)
         {
-            double value = (double) meterspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared);
+            return new Acceleration(meterspersecondsquared, AccelerationUnit.MeterPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MicrometerPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMicrometersPerSecondSquared(QuantityValue micrometerspersecondsquared)
+        public static Acceleration FromMicrometersPerSecondSquared(double micrometerspersecondsquared)
         {
-            double value = (double) micrometerspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared);
+            return new Acceleration(micrometerspersecondsquared, AccelerationUnit.MicrometerPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MillimeterPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMillimetersPerSecondSquared(QuantityValue millimeterspersecondsquared)
+        public static Acceleration FromMillimetersPerSecondSquared(double millimeterspersecondsquared)
         {
-            double value = (double) millimeterspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared);
+            return new Acceleration(millimeterspersecondsquared, AccelerationUnit.MillimeterPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MillistandardGravity"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMillistandardGravity(QuantityValue millistandardgravity)
+        public static Acceleration FromMillistandardGravity(double millistandardgravity)
         {
-            double value = (double) millistandardgravity;
-            return new Acceleration(value, AccelerationUnit.MillistandardGravity);
+            return new Acceleration(millistandardgravity, AccelerationUnit.MillistandardGravity);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.NanometerPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromNanometersPerSecondSquared(QuantityValue nanometerspersecondsquared)
+        public static Acceleration FromNanometersPerSecondSquared(double nanometerspersecondsquared)
         {
-            double value = (double) nanometerspersecondsquared;
-            return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared);
+            return new Acceleration(nanometerspersecondsquared, AccelerationUnit.NanometerPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.StandardGravity"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromStandardGravity(QuantityValue standardgravity)
+        public static Acceleration FromStandardGravity(double standardgravity)
         {
-            double value = (double) standardgravity;
-            return new Acceleration(value, AccelerationUnit.StandardGravity);
+            return new Acceleration(standardgravity, AccelerationUnit.StandardGravity);
         }
 
         /// <summary>
@@ -478,9 +464,9 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Acceleration unit value.</returns>
-        public static Acceleration From(QuantityValue value, AccelerationUnit fromUnit)
+        public static Acceleration From(double value, AccelerationUnit fromUnit)
         {
-            return new Acceleration((double)value, fromUnit);
+            return new Acceleration(value, fromUnit);
         }
 
         #endregion
@@ -937,15 +923,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is AccelerationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AccelerationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is AccelerationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AccelerationUnit)} is supported.", nameof(unit));
@@ -1086,18 +1063,6 @@ public Acceleration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AccelerationUnit> IQuantity<AccelerationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not AccelerationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AccelerationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
index 40c6a00dd8..af5a890bd8 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct AmountOfSubstance :
-        IArithmeticQuantity<AmountOfSubstance, AmountOfSubstanceUnit, double>,
+        IArithmeticQuantity<AmountOfSubstance, AmountOfSubstanceUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<AmountOfSubstance, MolarMass, Mass>,
         IDivisionOperators<AmountOfSubstance, Volume, Molarity>,
@@ -171,7 +171,7 @@ public AmountOfSubstance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -357,170 +357,153 @@ public static string GetAbbreviation(AmountOfSubstanceUnit unit, IFormatProvider
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Centimole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromCentimoles(QuantityValue centimoles)
+        public static AmountOfSubstance FromCentimoles(double centimoles)
         {
-            double value = (double) centimoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Centimole);
+            return new AmountOfSubstance(centimoles, AmountOfSubstanceUnit.Centimole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.CentipoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromCentipoundMoles(QuantityValue centipoundmoles)
+        public static AmountOfSubstance FromCentipoundMoles(double centipoundmoles)
         {
-            double value = (double) centipoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.CentipoundMole);
+            return new AmountOfSubstance(centipoundmoles, AmountOfSubstanceUnit.CentipoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Decimole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromDecimoles(QuantityValue decimoles)
+        public static AmountOfSubstance FromDecimoles(double decimoles)
         {
-            double value = (double) decimoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Decimole);
+            return new AmountOfSubstance(decimoles, AmountOfSubstanceUnit.Decimole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.DecipoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromDecipoundMoles(QuantityValue decipoundmoles)
+        public static AmountOfSubstance FromDecipoundMoles(double decipoundmoles)
         {
-            double value = (double) decipoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.DecipoundMole);
+            return new AmountOfSubstance(decipoundmoles, AmountOfSubstanceUnit.DecipoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Femtomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromFemtomoles(QuantityValue femtomoles)
+        public static AmountOfSubstance FromFemtomoles(double femtomoles)
         {
-            double value = (double) femtomoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Femtomole);
+            return new AmountOfSubstance(femtomoles, AmountOfSubstanceUnit.Femtomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Kilomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromKilomoles(QuantityValue kilomoles)
+        public static AmountOfSubstance FromKilomoles(double kilomoles)
         {
-            double value = (double) kilomoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Kilomole);
+            return new AmountOfSubstance(kilomoles, AmountOfSubstanceUnit.Kilomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.KilopoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromKilopoundMoles(QuantityValue kilopoundmoles)
+        public static AmountOfSubstance FromKilopoundMoles(double kilopoundmoles)
         {
-            double value = (double) kilopoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole);
+            return new AmountOfSubstance(kilopoundmoles, AmountOfSubstanceUnit.KilopoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Megamole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMegamoles(QuantityValue megamoles)
+        public static AmountOfSubstance FromMegamoles(double megamoles)
         {
-            double value = (double) megamoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole);
+            return new AmountOfSubstance(megamoles, AmountOfSubstanceUnit.Megamole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Micromole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMicromoles(QuantityValue micromoles)
+        public static AmountOfSubstance FromMicromoles(double micromoles)
         {
-            double value = (double) micromoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Micromole);
+            return new AmountOfSubstance(micromoles, AmountOfSubstanceUnit.Micromole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.MicropoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMicropoundMoles(QuantityValue micropoundmoles)
+        public static AmountOfSubstance FromMicropoundMoles(double micropoundmoles)
         {
-            double value = (double) micropoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.MicropoundMole);
+            return new AmountOfSubstance(micropoundmoles, AmountOfSubstanceUnit.MicropoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Millimole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMillimoles(QuantityValue millimoles)
+        public static AmountOfSubstance FromMillimoles(double millimoles)
         {
-            double value = (double) millimoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Millimole);
+            return new AmountOfSubstance(millimoles, AmountOfSubstanceUnit.Millimole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.MillipoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMillipoundMoles(QuantityValue millipoundmoles)
+        public static AmountOfSubstance FromMillipoundMoles(double millipoundmoles)
         {
-            double value = (double) millipoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.MillipoundMole);
+            return new AmountOfSubstance(millipoundmoles, AmountOfSubstanceUnit.MillipoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Mole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMoles(QuantityValue moles)
+        public static AmountOfSubstance FromMoles(double moles)
         {
-            double value = (double) moles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Mole);
+            return new AmountOfSubstance(moles, AmountOfSubstanceUnit.Mole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Nanomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromNanomoles(QuantityValue nanomoles)
+        public static AmountOfSubstance FromNanomoles(double nanomoles)
         {
-            double value = (double) nanomoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Nanomole);
+            return new AmountOfSubstance(nanomoles, AmountOfSubstanceUnit.Nanomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.NanopoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromNanopoundMoles(QuantityValue nanopoundmoles)
+        public static AmountOfSubstance FromNanopoundMoles(double nanopoundmoles)
         {
-            double value = (double) nanopoundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.NanopoundMole);
+            return new AmountOfSubstance(nanopoundmoles, AmountOfSubstanceUnit.NanopoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Picomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromPicomoles(QuantityValue picomoles)
+        public static AmountOfSubstance FromPicomoles(double picomoles)
         {
-            double value = (double) picomoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Picomole);
+            return new AmountOfSubstance(picomoles, AmountOfSubstanceUnit.Picomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.PoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromPoundMoles(QuantityValue poundmoles)
+        public static AmountOfSubstance FromPoundMoles(double poundmoles)
         {
-            double value = (double) poundmoles;
-            return new AmountOfSubstance(value, AmountOfSubstanceUnit.PoundMole);
+            return new AmountOfSubstance(poundmoles, AmountOfSubstanceUnit.PoundMole);
         }
 
         /// <summary>
@@ -529,9 +512,9 @@ public static AmountOfSubstance FromPoundMoles(QuantityValue poundmoles)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AmountOfSubstance unit value.</returns>
-        public static AmountOfSubstance From(QuantityValue value, AmountOfSubstanceUnit fromUnit)
+        public static AmountOfSubstance From(double value, AmountOfSubstanceUnit fromUnit)
         {
-            return new AmountOfSubstance((double)value, fromUnit);
+            return new AmountOfSubstance(value, fromUnit);
         }
 
         #endregion
@@ -964,15 +947,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is AmountOfSubstanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmountOfSubstanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is AmountOfSubstanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmountOfSubstanceUnit)} is supported.", nameof(unit));
@@ -1119,18 +1093,6 @@ public AmountOfSubstance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AmountOfSubstanceUnit> IQuantity<AmountOfSubstanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not AmountOfSubstanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmountOfSubstanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
index 431a7e8427..28965ce755 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct AmplitudeRatio :
-        IArithmeticQuantity<AmplitudeRatio, AmplitudeRatioUnit, double>,
+        IArithmeticQuantity<AmplitudeRatio, AmplitudeRatioUnit>,
         IComparable,
         IComparable<AmplitudeRatio>,
         IConvertible,
@@ -150,7 +150,7 @@ public AmplitudeRatio(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -245,40 +245,36 @@ public static string GetAbbreviation(AmplitudeRatioUnit unit, IFormatProvider? p
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelMicrovolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelMicrovolts(QuantityValue decibelmicrovolts)
+        public static AmplitudeRatio FromDecibelMicrovolts(double decibelmicrovolts)
         {
-            double value = (double) decibelmicrovolts;
-            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMicrovolt);
+            return new AmplitudeRatio(decibelmicrovolts, AmplitudeRatioUnit.DecibelMicrovolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelMillivolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelMillivolts(QuantityValue decibelmillivolts)
+        public static AmplitudeRatio FromDecibelMillivolts(double decibelmillivolts)
         {
-            double value = (double) decibelmillivolts;
-            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMillivolt);
+            return new AmplitudeRatio(decibelmillivolts, AmplitudeRatioUnit.DecibelMillivolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelUnloaded"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelsUnloaded(QuantityValue decibelsunloaded)
+        public static AmplitudeRatio FromDecibelsUnloaded(double decibelsunloaded)
         {
-            double value = (double) decibelsunloaded;
-            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelUnloaded);
+            return new AmplitudeRatio(decibelsunloaded, AmplitudeRatioUnit.DecibelUnloaded);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelVolts(QuantityValue decibelvolts)
+        public static AmplitudeRatio FromDecibelVolts(double decibelvolts)
         {
-            double value = (double) decibelvolts;
-            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelVolt);
+            return new AmplitudeRatio(decibelvolts, AmplitudeRatioUnit.DecibelVolt);
         }
 
         /// <summary>
@@ -287,9 +283,9 @@ public static AmplitudeRatio FromDecibelVolts(QuantityValue decibelvolts)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AmplitudeRatio unit value.</returns>
-        public static AmplitudeRatio From(QuantityValue value, AmplitudeRatioUnit fromUnit)
+        public static AmplitudeRatio From(double value, AmplitudeRatioUnit fromUnit)
         {
-            return new AmplitudeRatio((double)value, fromUnit);
+            return new AmplitudeRatio(value, fromUnit);
         }
 
         #endregion
@@ -473,14 +469,14 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Ampli
         public static AmplitudeRatio operator *(AmplitudeRatio left, double right)
         {
             // Logarithmic multiplication = addition
-            return new AmplitudeRatio(left.Value + (double)right, left.Unit);
+            return new AmplitudeRatio(left.Value + right, left.Unit);
         }
 
         /// <summary>Get <see cref="AmplitudeRatio"/> from logarithmic division of <see cref="AmplitudeRatio"/> by value.</summary>
         public static AmplitudeRatio operator /(AmplitudeRatio left, double right)
         {
             // Logarithmic division = subtraction
-            return new AmplitudeRatio(left.Value - (double)right, left.Unit);
+            return new AmplitudeRatio(left.Value - right, left.Unit);
         }
 
         /// <summary>Get ratio value from logarithmic division of <see cref="AmplitudeRatio"/> by <see cref="AmplitudeRatio"/>.</summary>
@@ -708,15 +704,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is AmplitudeRatioUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmplitudeRatioUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is AmplitudeRatioUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmplitudeRatioUnit)} is supported.", nameof(unit));
@@ -837,18 +824,6 @@ public AmplitudeRatio ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AmplitudeRatioUnit> IQuantity<AmplitudeRatioUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not AmplitudeRatioUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AmplitudeRatioUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
index 346157c773..9154199798 100644
--- a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Angle :
-        IArithmeticQuantity<Angle, AngleUnit, double>,
+        IArithmeticQuantity<Angle, AngleUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Angle, Duration, RotationalSpeed>,
         IDivisionOperators<Angle, TimeSpan, RotationalSpeed>,
@@ -170,7 +170,7 @@ public Angle(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -349,160 +349,144 @@ public static string GetAbbreviation(AngleUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Arcminute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromArcminutes(QuantityValue arcminutes)
+        public static Angle FromArcminutes(double arcminutes)
         {
-            double value = (double) arcminutes;
-            return new Angle(value, AngleUnit.Arcminute);
+            return new Angle(arcminutes, AngleUnit.Arcminute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Arcsecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromArcseconds(QuantityValue arcseconds)
+        public static Angle FromArcseconds(double arcseconds)
         {
-            double value = (double) arcseconds;
-            return new Angle(value, AngleUnit.Arcsecond);
+            return new Angle(arcseconds, AngleUnit.Arcsecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Centiradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromCentiradians(QuantityValue centiradians)
+        public static Angle FromCentiradians(double centiradians)
         {
-            double value = (double) centiradians;
-            return new Angle(value, AngleUnit.Centiradian);
+            return new Angle(centiradians, AngleUnit.Centiradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Deciradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromDeciradians(QuantityValue deciradians)
+        public static Angle FromDeciradians(double deciradians)
         {
-            double value = (double) deciradians;
-            return new Angle(value, AngleUnit.Deciradian);
+            return new Angle(deciradians, AngleUnit.Deciradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Degree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromDegrees(QuantityValue degrees)
+        public static Angle FromDegrees(double degrees)
         {
-            double value = (double) degrees;
-            return new Angle(value, AngleUnit.Degree);
+            return new Angle(degrees, AngleUnit.Degree);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Gradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromGradians(QuantityValue gradians)
+        public static Angle FromGradians(double gradians)
         {
-            double value = (double) gradians;
-            return new Angle(value, AngleUnit.Gradian);
+            return new Angle(gradians, AngleUnit.Gradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Microdegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMicrodegrees(QuantityValue microdegrees)
+        public static Angle FromMicrodegrees(double microdegrees)
         {
-            double value = (double) microdegrees;
-            return new Angle(value, AngleUnit.Microdegree);
+            return new Angle(microdegrees, AngleUnit.Microdegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Microradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMicroradians(QuantityValue microradians)
+        public static Angle FromMicroradians(double microradians)
         {
-            double value = (double) microradians;
-            return new Angle(value, AngleUnit.Microradian);
+            return new Angle(microradians, AngleUnit.Microradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Millidegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMillidegrees(QuantityValue millidegrees)
+        public static Angle FromMillidegrees(double millidegrees)
         {
-            double value = (double) millidegrees;
-            return new Angle(value, AngleUnit.Millidegree);
+            return new Angle(millidegrees, AngleUnit.Millidegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Milliradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMilliradians(QuantityValue milliradians)
+        public static Angle FromMilliradians(double milliradians)
         {
-            double value = (double) milliradians;
-            return new Angle(value, AngleUnit.Milliradian);
+            return new Angle(milliradians, AngleUnit.Milliradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Nanodegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromNanodegrees(QuantityValue nanodegrees)
+        public static Angle FromNanodegrees(double nanodegrees)
         {
-            double value = (double) nanodegrees;
-            return new Angle(value, AngleUnit.Nanodegree);
+            return new Angle(nanodegrees, AngleUnit.Nanodegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Nanoradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromNanoradians(QuantityValue nanoradians)
+        public static Angle FromNanoradians(double nanoradians)
         {
-            double value = (double) nanoradians;
-            return new Angle(value, AngleUnit.Nanoradian);
+            return new Angle(nanoradians, AngleUnit.Nanoradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.NatoMil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromNatoMils(QuantityValue natomils)
+        public static Angle FromNatoMils(double natomils)
         {
-            double value = (double) natomils;
-            return new Angle(value, AngleUnit.NatoMil);
+            return new Angle(natomils, AngleUnit.NatoMil);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Radian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromRadians(QuantityValue radians)
+        public static Angle FromRadians(double radians)
         {
-            double value = (double) radians;
-            return new Angle(value, AngleUnit.Radian);
+            return new Angle(radians, AngleUnit.Radian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Revolution"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromRevolutions(QuantityValue revolutions)
+        public static Angle FromRevolutions(double revolutions)
         {
-            double value = (double) revolutions;
-            return new Angle(value, AngleUnit.Revolution);
+            return new Angle(revolutions, AngleUnit.Revolution);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Tilt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromTilt(QuantityValue tilt)
+        public static Angle FromTilt(double tilt)
         {
-            double value = (double) tilt;
-            return new Angle(value, AngleUnit.Tilt);
+            return new Angle(tilt, AngleUnit.Tilt);
         }
 
         /// <summary>
@@ -511,9 +495,9 @@ public static Angle FromTilt(QuantityValue tilt)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Angle unit value.</returns>
-        public static Angle From(QuantityValue value, AngleUnit fromUnit)
+        public static Angle From(double value, AngleUnit fromUnit)
         {
-            return new Angle((double)value, fromUnit);
+            return new Angle(value, fromUnit);
         }
 
         #endregion
@@ -946,15 +930,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is AngleUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AngleUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is AngleUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AngleUnit)} is supported.", nameof(unit));
@@ -1099,18 +1074,6 @@ public Angle ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AngleUnit> IQuantity<AngleUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not AngleUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AngleUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
index 37b8d8e526..368a86ea9f 100644
--- a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ApparentEnergy :
-        IArithmeticQuantity<ApparentEnergy, ApparentEnergyUnit, double>,
+        IArithmeticQuantity<ApparentEnergy, ApparentEnergyUnit>,
         IComparable,
         IComparable<ApparentEnergy>,
         IConvertible,
@@ -149,7 +149,7 @@ public ApparentEnergy(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -237,30 +237,27 @@ public static string GetAbbreviation(ApparentEnergyUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ApparentEnergy"/> from <see cref="ApparentEnergyUnit.KilovoltampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromKilovoltampereHours(QuantityValue kilovoltamperehours)
+        public static ApparentEnergy FromKilovoltampereHours(double kilovoltamperehours)
         {
-            double value = (double) kilovoltamperehours;
-            return new ApparentEnergy(value, ApparentEnergyUnit.KilovoltampereHour);
+            return new ApparentEnergy(kilovoltamperehours, ApparentEnergyUnit.KilovoltampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentEnergy"/> from <see cref="ApparentEnergyUnit.MegavoltampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromMegavoltampereHours(QuantityValue megavoltamperehours)
+        public static ApparentEnergy FromMegavoltampereHours(double megavoltamperehours)
         {
-            double value = (double) megavoltamperehours;
-            return new ApparentEnergy(value, ApparentEnergyUnit.MegavoltampereHour);
+            return new ApparentEnergy(megavoltamperehours, ApparentEnergyUnit.MegavoltampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentEnergy"/> from <see cref="ApparentEnergyUnit.VoltampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromVoltampereHours(QuantityValue voltamperehours)
+        public static ApparentEnergy FromVoltampereHours(double voltamperehours)
         {
-            double value = (double) voltamperehours;
-            return new ApparentEnergy(value, ApparentEnergyUnit.VoltampereHour);
+            return new ApparentEnergy(voltamperehours, ApparentEnergyUnit.VoltampereHour);
         }
 
         /// <summary>
@@ -269,9 +266,9 @@ public static ApparentEnergy FromVoltampereHours(QuantityValue voltamperehours)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ApparentEnergy unit value.</returns>
-        public static ApparentEnergy From(QuantityValue value, ApparentEnergyUnit fromUnit)
+        public static ApparentEnergy From(double value, ApparentEnergyUnit fromUnit)
         {
-            return new ApparentEnergy((double)value, fromUnit);
+            return new ApparentEnergy(value, fromUnit);
         }
 
         #endregion
@@ -682,15 +679,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ApparentEnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ApparentEnergyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ApparentEnergyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ApparentEnergyUnit)} is supported.", nameof(unit));
@@ -809,18 +797,6 @@ public ApparentEnergy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ApparentEnergyUnit> IQuantity<ApparentEnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ApparentEnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ApparentEnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
index f4096ac654..b05a40ab9e 100644
--- a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ApparentPower :
-        IArithmeticQuantity<ApparentPower, ApparentPowerUnit, double>,
+        IArithmeticQuantity<ApparentPower, ApparentPowerUnit>,
         IComparable,
         IComparable<ApparentPower>,
         IConvertible,
@@ -152,7 +152,7 @@ public ApparentPower(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -261,60 +261,54 @@ public static string GetAbbreviation(ApparentPowerUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Gigavoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromGigavoltamperes(QuantityValue gigavoltamperes)
+        public static ApparentPower FromGigavoltamperes(double gigavoltamperes)
         {
-            double value = (double) gigavoltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Gigavoltampere);
+            return new ApparentPower(gigavoltamperes, ApparentPowerUnit.Gigavoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Kilovoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromKilovoltamperes(QuantityValue kilovoltamperes)
+        public static ApparentPower FromKilovoltamperes(double kilovoltamperes)
         {
-            double value = (double) kilovoltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Kilovoltampere);
+            return new ApparentPower(kilovoltamperes, ApparentPowerUnit.Kilovoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Megavoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromMegavoltamperes(QuantityValue megavoltamperes)
+        public static ApparentPower FromMegavoltamperes(double megavoltamperes)
         {
-            double value = (double) megavoltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Megavoltampere);
+            return new ApparentPower(megavoltamperes, ApparentPowerUnit.Megavoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Microvoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromMicrovoltamperes(QuantityValue microvoltamperes)
+        public static ApparentPower FromMicrovoltamperes(double microvoltamperes)
         {
-            double value = (double) microvoltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Microvoltampere);
+            return new ApparentPower(microvoltamperes, ApparentPowerUnit.Microvoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Millivoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromMillivoltamperes(QuantityValue millivoltamperes)
+        public static ApparentPower FromMillivoltamperes(double millivoltamperes)
         {
-            double value = (double) millivoltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Millivoltampere);
+            return new ApparentPower(millivoltamperes, ApparentPowerUnit.Millivoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Voltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromVoltamperes(QuantityValue voltamperes)
+        public static ApparentPower FromVoltamperes(double voltamperes)
         {
-            double value = (double) voltamperes;
-            return new ApparentPower(value, ApparentPowerUnit.Voltampere);
+            return new ApparentPower(voltamperes, ApparentPowerUnit.Voltampere);
         }
 
         /// <summary>
@@ -323,9 +317,9 @@ public static ApparentPower FromVoltamperes(QuantityValue voltamperes)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ApparentPower unit value.</returns>
-        public static ApparentPower From(QuantityValue value, ApparentPowerUnit fromUnit)
+        public static ApparentPower From(double value, ApparentPowerUnit fromUnit)
         {
-            return new ApparentPower((double)value, fromUnit);
+            return new ApparentPower(value, fromUnit);
         }
 
         #endregion
@@ -736,15 +730,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ApparentPowerUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ApparentPowerUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ApparentPowerUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ApparentPowerUnit)} is supported.", nameof(unit));
@@ -869,18 +854,6 @@ public ApparentPower ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ApparentPowerUnit> IQuantity<ApparentPowerUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ApparentPowerUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ApparentPowerUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Area.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
index 613ed2e8dd..4f8c25c7a0 100644
--- a/UnitsNet/GeneratedCode/Quantities/Area.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Area :
-        IArithmeticQuantity<Area, AreaUnit, double>,
+        IArithmeticQuantity<Area, AreaUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Area, Pressure, Force>,
         IMultiplyOperators<Area, SpecificWeight, ForcePerLength>,
@@ -177,7 +177,7 @@ public Area(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -342,140 +342,126 @@ public static string GetAbbreviation(AreaUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.Acre"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromAcres(QuantityValue acres)
+        public static Area FromAcres(double acres)
         {
-            double value = (double) acres;
-            return new Area(value, AreaUnit.Acre);
+            return new Area(acres, AreaUnit.Acre);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.Hectare"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromHectares(QuantityValue hectares)
+        public static Area FromHectares(double hectares)
         {
-            double value = (double) hectares;
-            return new Area(value, AreaUnit.Hectare);
+            return new Area(hectares, AreaUnit.Hectare);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareCentimeters(QuantityValue squarecentimeters)
+        public static Area FromSquareCentimeters(double squarecentimeters)
         {
-            double value = (double) squarecentimeters;
-            return new Area(value, AreaUnit.SquareCentimeter);
+            return new Area(squarecentimeters, AreaUnit.SquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareDecimeters(QuantityValue squaredecimeters)
+        public static Area FromSquareDecimeters(double squaredecimeters)
         {
-            double value = (double) squaredecimeters;
-            return new Area(value, AreaUnit.SquareDecimeter);
+            return new Area(squaredecimeters, AreaUnit.SquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareFeet(QuantityValue squarefeet)
+        public static Area FromSquareFeet(double squarefeet)
         {
-            double value = (double) squarefeet;
-            return new Area(value, AreaUnit.SquareFoot);
+            return new Area(squarefeet, AreaUnit.SquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareInches(QuantityValue squareinches)
+        public static Area FromSquareInches(double squareinches)
         {
-            double value = (double) squareinches;
-            return new Area(value, AreaUnit.SquareInch);
+            return new Area(squareinches, AreaUnit.SquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareKilometers(QuantityValue squarekilometers)
+        public static Area FromSquareKilometers(double squarekilometers)
         {
-            double value = (double) squarekilometers;
-            return new Area(value, AreaUnit.SquareKilometer);
+            return new Area(squarekilometers, AreaUnit.SquareKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMeters(QuantityValue squaremeters)
+        public static Area FromSquareMeters(double squaremeters)
         {
-            double value = (double) squaremeters;
-            return new Area(value, AreaUnit.SquareMeter);
+            return new Area(squaremeters, AreaUnit.SquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMicrometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMicrometers(QuantityValue squaremicrometers)
+        public static Area FromSquareMicrometers(double squaremicrometers)
         {
-            double value = (double) squaremicrometers;
-            return new Area(value, AreaUnit.SquareMicrometer);
+            return new Area(squaremicrometers, AreaUnit.SquareMicrometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMiles(QuantityValue squaremiles)
+        public static Area FromSquareMiles(double squaremiles)
         {
-            double value = (double) squaremiles;
-            return new Area(value, AreaUnit.SquareMile);
+            return new Area(squaremiles, AreaUnit.SquareMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMillimeters(QuantityValue squaremillimeters)
+        public static Area FromSquareMillimeters(double squaremillimeters)
         {
-            double value = (double) squaremillimeters;
-            return new Area(value, AreaUnit.SquareMillimeter);
+            return new Area(squaremillimeters, AreaUnit.SquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareNauticalMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareNauticalMiles(QuantityValue squarenauticalmiles)
+        public static Area FromSquareNauticalMiles(double squarenauticalmiles)
         {
-            double value = (double) squarenauticalmiles;
-            return new Area(value, AreaUnit.SquareNauticalMile);
+            return new Area(squarenauticalmiles, AreaUnit.SquareNauticalMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareYards(QuantityValue squareyards)
+        public static Area FromSquareYards(double squareyards)
         {
-            double value = (double) squareyards;
-            return new Area(value, AreaUnit.SquareYard);
+            return new Area(squareyards, AreaUnit.SquareYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.UsSurveySquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromUsSurveySquareFeet(QuantityValue ussurveysquarefeet)
+        public static Area FromUsSurveySquareFeet(double ussurveysquarefeet)
         {
-            double value = (double) ussurveysquarefeet;
-            return new Area(value, AreaUnit.UsSurveySquareFoot);
+            return new Area(ussurveysquarefeet, AreaUnit.UsSurveySquareFoot);
         }
 
         /// <summary>
@@ -484,9 +470,9 @@ public static Area FromUsSurveySquareFeet(QuantityValue ussurveysquarefeet)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Area unit value.</returns>
-        public static Area From(QuantityValue value, AreaUnit fromUnit)
+        public static Area From(double value, AreaUnit fromUnit)
         {
-            return new Area((double)value, fromUnit);
+            return new Area(value, fromUnit);
         }
 
         #endregion
@@ -980,15 +966,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is AreaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is AreaUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaUnit)} is supported.", nameof(unit));
@@ -1129,18 +1106,6 @@ public Area ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AreaUnit> IQuantity<AreaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not AreaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
index 2124570e77..dc3473d5dc 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct AreaDensity :
-        IArithmeticQuantity<AreaDensity, AreaDensityUnit, double>,
+        IArithmeticQuantity<AreaDensity, AreaDensityUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<AreaDensity, Area, Mass>,
 #endif
@@ -155,7 +155,7 @@ public AreaDensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -243,30 +243,27 @@ public static string GetAbbreviation(AreaDensityUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.GramPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaDensity FromGramsPerSquareMeter(QuantityValue gramspersquaremeter)
+        public static AreaDensity FromGramsPerSquareMeter(double gramspersquaremeter)
         {
-            double value = (double) gramspersquaremeter;
-            return new AreaDensity(value, AreaDensityUnit.GramPerSquareMeter);
+            return new AreaDensity(gramspersquaremeter, AreaDensityUnit.GramPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.KilogramPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaDensity FromKilogramsPerSquareMeter(QuantityValue kilogramspersquaremeter)
+        public static AreaDensity FromKilogramsPerSquareMeter(double kilogramspersquaremeter)
         {
-            double value = (double) kilogramspersquaremeter;
-            return new AreaDensity(value, AreaDensityUnit.KilogramPerSquareMeter);
+            return new AreaDensity(kilogramspersquaremeter, AreaDensityUnit.KilogramPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.MilligramPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaDensity FromMilligramsPerSquareMeter(QuantityValue milligramspersquaremeter)
+        public static AreaDensity FromMilligramsPerSquareMeter(double milligramspersquaremeter)
         {
-            double value = (double) milligramspersquaremeter;
-            return new AreaDensity(value, AreaDensityUnit.MilligramPerSquareMeter);
+            return new AreaDensity(milligramspersquaremeter, AreaDensityUnit.MilligramPerSquareMeter);
         }
 
         /// <summary>
@@ -275,9 +272,9 @@ public static AreaDensity FromMilligramsPerSquareMeter(QuantityValue milligramsp
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AreaDensity unit value.</returns>
-        public static AreaDensity From(QuantityValue value, AreaDensityUnit fromUnit)
+        public static AreaDensity From(double value, AreaDensityUnit fromUnit)
         {
-            return new AreaDensity((double)value, fromUnit);
+            return new AreaDensity(value, fromUnit);
         }
 
         #endregion
@@ -698,15 +695,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is AreaDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaDensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is AreaDensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaDensityUnit)} is supported.", nameof(unit));
@@ -825,18 +813,6 @@ public AreaDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AreaDensityUnit> IQuantity<AreaDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not AreaDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
index acfe0f659c..78f1ad2b29 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct AreaMomentOfInertia :
-        IArithmeticQuantity<AreaMomentOfInertia, AreaMomentOfInertiaUnit, double>,
+        IArithmeticQuantity<AreaMomentOfInertia, AreaMomentOfInertiaUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<AreaMomentOfInertia, Length, Volume>,
 #endif
@@ -158,7 +158,7 @@ public AreaMomentOfInertia(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -267,60 +267,54 @@ public static string GetAbbreviation(AreaMomentOfInertiaUnit unit, IFormatProvid
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.CentimeterToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromCentimetersToTheFourth(QuantityValue centimeterstothefourth)
+        public static AreaMomentOfInertia FromCentimetersToTheFourth(double centimeterstothefourth)
         {
-            double value = (double) centimeterstothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
+            return new AreaMomentOfInertia(centimeterstothefourth, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.DecimeterToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromDecimetersToTheFourth(QuantityValue decimeterstothefourth)
+        public static AreaMomentOfInertia FromDecimetersToTheFourth(double decimeterstothefourth)
         {
-            double value = (double) decimeterstothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
+            return new AreaMomentOfInertia(decimeterstothefourth, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.FootToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromFeetToTheFourth(QuantityValue feettothefourth)
+        public static AreaMomentOfInertia FromFeetToTheFourth(double feettothefourth)
         {
-            double value = (double) feettothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.FootToTheFourth);
+            return new AreaMomentOfInertia(feettothefourth, AreaMomentOfInertiaUnit.FootToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.InchToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromInchesToTheFourth(QuantityValue inchestothefourth)
+        public static AreaMomentOfInertia FromInchesToTheFourth(double inchestothefourth)
         {
-            double value = (double) inchestothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.InchToTheFourth);
+            return new AreaMomentOfInertia(inchestothefourth, AreaMomentOfInertiaUnit.InchToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.MeterToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromMetersToTheFourth(QuantityValue meterstothefourth)
+        public static AreaMomentOfInertia FromMetersToTheFourth(double meterstothefourth)
         {
-            double value = (double) meterstothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MeterToTheFourth);
+            return new AreaMomentOfInertia(meterstothefourth, AreaMomentOfInertiaUnit.MeterToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.MillimeterToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromMillimetersToTheFourth(QuantityValue millimeterstothefourth)
+        public static AreaMomentOfInertia FromMillimetersToTheFourth(double millimeterstothefourth)
         {
-            double value = (double) millimeterstothefourth;
-            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
+            return new AreaMomentOfInertia(millimeterstothefourth, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
         }
 
         /// <summary>
@@ -329,9 +323,9 @@ public static AreaMomentOfInertia FromMillimetersToTheFourth(QuantityValue milli
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>AreaMomentOfInertia unit value.</returns>
-        public static AreaMomentOfInertia From(QuantityValue value, AreaMomentOfInertiaUnit fromUnit)
+        public static AreaMomentOfInertia From(double value, AreaMomentOfInertiaUnit fromUnit)
         {
-            return new AreaMomentOfInertia((double)value, fromUnit);
+            return new AreaMomentOfInertia(value, fromUnit);
         }
 
         #endregion
@@ -752,15 +746,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is AreaMomentOfInertiaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is AreaMomentOfInertiaUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaMomentOfInertiaUnit)} is supported.", nameof(unit));
@@ -885,18 +870,6 @@ public AreaMomentOfInertia ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<AreaMomentOfInertiaUnit> IQuantity<AreaMomentOfInertiaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not AreaMomentOfInertiaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(AreaMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
index 22ef4aa2fa..ccfb357344 100644
--- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct BitRate :
-        IArithmeticQuantity<BitRate, BitRateUnit, double>,
+        IArithmeticQuantity<BitRate, BitRateUnit>,
         IComparable,
         IComparable<BitRate>,
         IConvertible,
@@ -175,7 +175,7 @@ public BitRate(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -424,260 +424,234 @@ public static string GetAbbreviation(BitRateUnit unit, IFormatProvider? provider
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.BitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromBitsPerSecond(QuantityValue bitspersecond)
+        public static BitRate FromBitsPerSecond(double bitspersecond)
         {
-            double value = (double) bitspersecond;
-            return new BitRate(value, BitRateUnit.BitPerSecond);
+            return new BitRate(bitspersecond, BitRateUnit.BitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.BytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromBytesPerSecond(QuantityValue bytespersecond)
+        public static BitRate FromBytesPerSecond(double bytespersecond)
         {
-            double value = (double) bytespersecond;
-            return new BitRate(value, BitRateUnit.BytePerSecond);
+            return new BitRate(bytespersecond, BitRateUnit.BytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExabitsPerSecond(QuantityValue exabitspersecond)
+        public static BitRate FromExabitsPerSecond(double exabitspersecond)
         {
-            double value = (double) exabitspersecond;
-            return new BitRate(value, BitRateUnit.ExabitPerSecond);
+            return new BitRate(exabitspersecond, BitRateUnit.ExabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExabytesPerSecond(QuantityValue exabytespersecond)
+        public static BitRate FromExabytesPerSecond(double exabytespersecond)
         {
-            double value = (double) exabytespersecond;
-            return new BitRate(value, BitRateUnit.ExabytePerSecond);
+            return new BitRate(exabytespersecond, BitRateUnit.ExabytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExbibitsPerSecond(QuantityValue exbibitspersecond)
+        public static BitRate FromExbibitsPerSecond(double exbibitspersecond)
         {
-            double value = (double) exbibitspersecond;
-            return new BitRate(value, BitRateUnit.ExbibitPerSecond);
+            return new BitRate(exbibitspersecond, BitRateUnit.ExbibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExbibytesPerSecond(QuantityValue exbibytespersecond)
+        public static BitRate FromExbibytesPerSecond(double exbibytespersecond)
         {
-            double value = (double) exbibytespersecond;
-            return new BitRate(value, BitRateUnit.ExbibytePerSecond);
+            return new BitRate(exbibytespersecond, BitRateUnit.ExbibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGibibitsPerSecond(QuantityValue gibibitspersecond)
+        public static BitRate FromGibibitsPerSecond(double gibibitspersecond)
         {
-            double value = (double) gibibitspersecond;
-            return new BitRate(value, BitRateUnit.GibibitPerSecond);
+            return new BitRate(gibibitspersecond, BitRateUnit.GibibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGibibytesPerSecond(QuantityValue gibibytespersecond)
+        public static BitRate FromGibibytesPerSecond(double gibibytespersecond)
         {
-            double value = (double) gibibytespersecond;
-            return new BitRate(value, BitRateUnit.GibibytePerSecond);
+            return new BitRate(gibibytespersecond, BitRateUnit.GibibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGigabitsPerSecond(QuantityValue gigabitspersecond)
+        public static BitRate FromGigabitsPerSecond(double gigabitspersecond)
         {
-            double value = (double) gigabitspersecond;
-            return new BitRate(value, BitRateUnit.GigabitPerSecond);
+            return new BitRate(gigabitspersecond, BitRateUnit.GigabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGigabytesPerSecond(QuantityValue gigabytespersecond)
+        public static BitRate FromGigabytesPerSecond(double gigabytespersecond)
         {
-            double value = (double) gigabytespersecond;
-            return new BitRate(value, BitRateUnit.GigabytePerSecond);
+            return new BitRate(gigabytespersecond, BitRateUnit.GigabytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKibibitsPerSecond(QuantityValue kibibitspersecond)
+        public static BitRate FromKibibitsPerSecond(double kibibitspersecond)
         {
-            double value = (double) kibibitspersecond;
-            return new BitRate(value, BitRateUnit.KibibitPerSecond);
+            return new BitRate(kibibitspersecond, BitRateUnit.KibibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKibibytesPerSecond(QuantityValue kibibytespersecond)
+        public static BitRate FromKibibytesPerSecond(double kibibytespersecond)
         {
-            double value = (double) kibibytespersecond;
-            return new BitRate(value, BitRateUnit.KibibytePerSecond);
+            return new BitRate(kibibytespersecond, BitRateUnit.KibibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilobitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKilobitsPerSecond(QuantityValue kilobitspersecond)
+        public static BitRate FromKilobitsPerSecond(double kilobitspersecond)
         {
-            double value = (double) kilobitspersecond;
-            return new BitRate(value, BitRateUnit.KilobitPerSecond);
+            return new BitRate(kilobitspersecond, BitRateUnit.KilobitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilobytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKilobytesPerSecond(QuantityValue kilobytespersecond)
+        public static BitRate FromKilobytesPerSecond(double kilobytespersecond)
         {
-            double value = (double) kilobytespersecond;
-            return new BitRate(value, BitRateUnit.KilobytePerSecond);
+            return new BitRate(kilobytespersecond, BitRateUnit.KilobytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMebibitsPerSecond(QuantityValue mebibitspersecond)
+        public static BitRate FromMebibitsPerSecond(double mebibitspersecond)
         {
-            double value = (double) mebibitspersecond;
-            return new BitRate(value, BitRateUnit.MebibitPerSecond);
+            return new BitRate(mebibitspersecond, BitRateUnit.MebibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMebibytesPerSecond(QuantityValue mebibytespersecond)
+        public static BitRate FromMebibytesPerSecond(double mebibytespersecond)
         {
-            double value = (double) mebibytespersecond;
-            return new BitRate(value, BitRateUnit.MebibytePerSecond);
+            return new BitRate(mebibytespersecond, BitRateUnit.MebibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMegabitsPerSecond(QuantityValue megabitspersecond)
+        public static BitRate FromMegabitsPerSecond(double megabitspersecond)
         {
-            double value = (double) megabitspersecond;
-            return new BitRate(value, BitRateUnit.MegabitPerSecond);
+            return new BitRate(megabitspersecond, BitRateUnit.MegabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMegabytesPerSecond(QuantityValue megabytespersecond)
+        public static BitRate FromMegabytesPerSecond(double megabytespersecond)
         {
-            double value = (double) megabytespersecond;
-            return new BitRate(value, BitRateUnit.MegabytePerSecond);
+            return new BitRate(megabytespersecond, BitRateUnit.MegabytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPebibitsPerSecond(QuantityValue pebibitspersecond)
+        public static BitRate FromPebibitsPerSecond(double pebibitspersecond)
         {
-            double value = (double) pebibitspersecond;
-            return new BitRate(value, BitRateUnit.PebibitPerSecond);
+            return new BitRate(pebibitspersecond, BitRateUnit.PebibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPebibytesPerSecond(QuantityValue pebibytespersecond)
+        public static BitRate FromPebibytesPerSecond(double pebibytespersecond)
         {
-            double value = (double) pebibytespersecond;
-            return new BitRate(value, BitRateUnit.PebibytePerSecond);
+            return new BitRate(pebibytespersecond, BitRateUnit.PebibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPetabitsPerSecond(QuantityValue petabitspersecond)
+        public static BitRate FromPetabitsPerSecond(double petabitspersecond)
         {
-            double value = (double) petabitspersecond;
-            return new BitRate(value, BitRateUnit.PetabitPerSecond);
+            return new BitRate(petabitspersecond, BitRateUnit.PetabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPetabytesPerSecond(QuantityValue petabytespersecond)
+        public static BitRate FromPetabytesPerSecond(double petabytespersecond)
         {
-            double value = (double) petabytespersecond;
-            return new BitRate(value, BitRateUnit.PetabytePerSecond);
+            return new BitRate(petabytespersecond, BitRateUnit.PetabytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTebibitsPerSecond(QuantityValue tebibitspersecond)
+        public static BitRate FromTebibitsPerSecond(double tebibitspersecond)
         {
-            double value = (double) tebibitspersecond;
-            return new BitRate(value, BitRateUnit.TebibitPerSecond);
+            return new BitRate(tebibitspersecond, BitRateUnit.TebibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTebibytesPerSecond(QuantityValue tebibytespersecond)
+        public static BitRate FromTebibytesPerSecond(double tebibytespersecond)
         {
-            double value = (double) tebibytespersecond;
-            return new BitRate(value, BitRateUnit.TebibytePerSecond);
+            return new BitRate(tebibytespersecond, BitRateUnit.TebibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TerabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTerabitsPerSecond(QuantityValue terabitspersecond)
+        public static BitRate FromTerabitsPerSecond(double terabitspersecond)
         {
-            double value = (double) terabitspersecond;
-            return new BitRate(value, BitRateUnit.TerabitPerSecond);
+            return new BitRate(terabitspersecond, BitRateUnit.TerabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TerabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTerabytesPerSecond(QuantityValue terabytespersecond)
+        public static BitRate FromTerabytesPerSecond(double terabytespersecond)
         {
-            double value = (double) terabytespersecond;
-            return new BitRate(value, BitRateUnit.TerabytePerSecond);
+            return new BitRate(terabytespersecond, BitRateUnit.TerabytePerSecond);
         }
 
         /// <summary>
@@ -686,9 +660,9 @@ public static BitRate FromTerabytesPerSecond(QuantityValue terabytespersecond)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>BitRate unit value.</returns>
-        public static BitRate From(QuantityValue value, BitRateUnit fromUnit)
+        public static BitRate From(double value, BitRateUnit fromUnit)
         {
-            return new BitRate((double)value, fromUnit);
+            return new BitRate(value, fromUnit);
         }
 
         #endregion
@@ -1099,15 +1073,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is BitRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BitRateUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is BitRateUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BitRateUnit)} is supported.", nameof(unit));
@@ -1272,18 +1237,6 @@ public BitRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<BitRateUnit> IQuantity<BitRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not BitRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BitRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
index e882651b01..f206c16e94 100644
--- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct BrakeSpecificFuelConsumption :
-        IArithmeticQuantity<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit, double>,
+        IArithmeticQuantity<BrakeSpecificFuelConsumption, BrakeSpecificFuelConsumptionUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<BrakeSpecificFuelConsumption, Power, MassFlow>,
         IMultiplyOperators<BrakeSpecificFuelConsumption, SpecificEnergy, double>,
@@ -156,7 +156,7 @@ public BrakeSpecificFuelConsumption(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -244,30 +244,27 @@ public static string GetAbbreviation(BrakeSpecificFuelConsumptionUnit unit, IFor
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(QuantityValue gramsperkilowatthour)
+        public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(double gramsperkilowatthour)
         {
-            double value = (double) gramsperkilowatthour;
-            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
+            return new BrakeSpecificFuelConsumption(gramsperkilowatthour, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.KilogramPerJoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(QuantityValue kilogramsperjoule)
+        public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(double kilogramsperjoule)
         {
-            double value = (double) kilogramsperjoule;
-            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
+            return new BrakeSpecificFuelConsumption(kilogramsperjoule, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour(QuantityValue poundspermechanicalhorsepowerhour)
+        public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour(double poundspermechanicalhorsepowerhour)
         {
-            double value = (double) poundspermechanicalhorsepowerhour;
-            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
+            return new BrakeSpecificFuelConsumption(poundspermechanicalhorsepowerhour, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
         }
 
         /// <summary>
@@ -276,9 +273,9 @@ public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>BrakeSpecificFuelConsumption unit value.</returns>
-        public static BrakeSpecificFuelConsumption From(QuantityValue value, BrakeSpecificFuelConsumptionUnit fromUnit)
+        public static BrakeSpecificFuelConsumption From(double value, BrakeSpecificFuelConsumptionUnit fromUnit)
         {
-            return new BrakeSpecificFuelConsumption((double)value, fromUnit);
+            return new BrakeSpecificFuelConsumption(value, fromUnit);
         }
 
         #endregion
@@ -711,15 +708,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is BrakeSpecificFuelConsumptionUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BrakeSpecificFuelConsumptionUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is BrakeSpecificFuelConsumptionUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BrakeSpecificFuelConsumptionUnit)} is supported.", nameof(unit));
@@ -838,18 +826,6 @@ public BrakeSpecificFuelConsumption ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<BrakeSpecificFuelConsumptionUnit> IQuantity<BrakeSpecificFuelConsumptionUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not BrakeSpecificFuelConsumptionUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(BrakeSpecificFuelConsumptionUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
index a36692fbd9..8d9907fa89 100644
--- a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Capacitance :
-        IArithmeticQuantity<Capacitance, CapacitanceUnit, double>,
+        IArithmeticQuantity<Capacitance, CapacitanceUnit>,
         IComparable,
         IComparable<Capacitance>,
         IConvertible,
@@ -156,7 +156,7 @@ public Capacitance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -272,70 +272,63 @@ public static string GetAbbreviation(CapacitanceUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Farad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromFarads(QuantityValue farads)
+        public static Capacitance FromFarads(double farads)
         {
-            double value = (double) farads;
-            return new Capacitance(value, CapacitanceUnit.Farad);
+            return new Capacitance(farads, CapacitanceUnit.Farad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Kilofarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromKilofarads(QuantityValue kilofarads)
+        public static Capacitance FromKilofarads(double kilofarads)
         {
-            double value = (double) kilofarads;
-            return new Capacitance(value, CapacitanceUnit.Kilofarad);
+            return new Capacitance(kilofarads, CapacitanceUnit.Kilofarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Megafarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMegafarads(QuantityValue megafarads)
+        public static Capacitance FromMegafarads(double megafarads)
         {
-            double value = (double) megafarads;
-            return new Capacitance(value, CapacitanceUnit.Megafarad);
+            return new Capacitance(megafarads, CapacitanceUnit.Megafarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Microfarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMicrofarads(QuantityValue microfarads)
+        public static Capacitance FromMicrofarads(double microfarads)
         {
-            double value = (double) microfarads;
-            return new Capacitance(value, CapacitanceUnit.Microfarad);
+            return new Capacitance(microfarads, CapacitanceUnit.Microfarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Millifarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMillifarads(QuantityValue millifarads)
+        public static Capacitance FromMillifarads(double millifarads)
         {
-            double value = (double) millifarads;
-            return new Capacitance(value, CapacitanceUnit.Millifarad);
+            return new Capacitance(millifarads, CapacitanceUnit.Millifarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Nanofarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromNanofarads(QuantityValue nanofarads)
+        public static Capacitance FromNanofarads(double nanofarads)
         {
-            double value = (double) nanofarads;
-            return new Capacitance(value, CapacitanceUnit.Nanofarad);
+            return new Capacitance(nanofarads, CapacitanceUnit.Nanofarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Picofarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromPicofarads(QuantityValue picofarads)
+        public static Capacitance FromPicofarads(double picofarads)
         {
-            double value = (double) picofarads;
-            return new Capacitance(value, CapacitanceUnit.Picofarad);
+            return new Capacitance(picofarads, CapacitanceUnit.Picofarad);
         }
 
         /// <summary>
@@ -344,9 +337,9 @@ public static Capacitance FromPicofarads(QuantityValue picofarads)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Capacitance unit value.</returns>
-        public static Capacitance From(QuantityValue value, CapacitanceUnit fromUnit)
+        public static Capacitance From(double value, CapacitanceUnit fromUnit)
         {
-            return new Capacitance((double)value, fromUnit);
+            return new Capacitance(value, fromUnit);
         }
 
         #endregion
@@ -757,15 +750,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is CapacitanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CapacitanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is CapacitanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CapacitanceUnit)} is supported.", nameof(unit));
@@ -892,18 +876,6 @@ public Capacitance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<CapacitanceUnit> IQuantity<CapacitanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not CapacitanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CapacitanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
index 656daf8952..cbd02a5a19 100644
--- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct CoefficientOfThermalExpansion :
-        IArithmeticQuantity<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit, double>,
+        IArithmeticQuantity<CoefficientOfThermalExpansion, CoefficientOfThermalExpansionUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<CoefficientOfThermalExpansion, TemperatureDelta, double>,
 #endif
@@ -161,7 +161,7 @@ public CoefficientOfThermalExpansion(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -295,10 +295,9 @@ public static string GetAbbreviation(CoefficientOfThermalExpansionUnit unit, IFo
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         [Obsolete("Use PerDegreeCelsius instead.")]
-        public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(QuantityValue inversedegreecelsius)
+        public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(double inversedegreecelsius)
         {
-            double value = (double) inversedegreecelsius;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
+            return new CoefficientOfThermalExpansion(inversedegreecelsius, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
         }
 
         /// <summary>
@@ -306,10 +305,9 @@ public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(QuantityVal
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         [Obsolete("Use PerDegreeFahrenheit instead.")]
-        public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(QuantityValue inversedegreefahrenheit)
+        public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(double inversedegreefahrenheit)
         {
-            double value = (double) inversedegreefahrenheit;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
+            return new CoefficientOfThermalExpansion(inversedegreefahrenheit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
         }
 
         /// <summary>
@@ -317,70 +315,63 @@ public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(Quantity
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         [Obsolete("Use PerKelvin instead.")]
-        public static CoefficientOfThermalExpansion FromInverseKelvin(QuantityValue inversekelvin)
+        public static CoefficientOfThermalExpansion FromInverseKelvin(double inversekelvin)
         {
-            double value = (double) inversekelvin;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseKelvin);
+            return new CoefficientOfThermalExpansion(inversekelvin, CoefficientOfThermalExpansionUnit.InverseKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPerDegreeCelsius(QuantityValue perdegreecelsius)
+        public static CoefficientOfThermalExpansion FromPerDegreeCelsius(double perdegreecelsius)
         {
-            double value = (double) perdegreecelsius;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
+            return new CoefficientOfThermalExpansion(perdegreecelsius, CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPerDegreeFahrenheit(QuantityValue perdegreefahrenheit)
+        public static CoefficientOfThermalExpansion FromPerDegreeFahrenheit(double perdegreefahrenheit)
         {
-            double value = (double) perdegreefahrenheit;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
+            return new CoefficientOfThermalExpansion(perdegreefahrenheit, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPerKelvin(QuantityValue perkelvin)
+        public static CoefficientOfThermalExpansion FromPerKelvin(double perkelvin)
         {
-            double value = (double) perkelvin;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerKelvin);
+            return new CoefficientOfThermalExpansion(perkelvin, CoefficientOfThermalExpansionUnit.PerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPpmPerDegreeCelsius(QuantityValue ppmperdegreecelsius)
+        public static CoefficientOfThermalExpansion FromPpmPerDegreeCelsius(double ppmperdegreecelsius)
         {
-            double value = (double) ppmperdegreecelsius;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
+            return new CoefficientOfThermalExpansion(ppmperdegreecelsius, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPpmPerDegreeFahrenheit(QuantityValue ppmperdegreefahrenheit)
+        public static CoefficientOfThermalExpansion FromPpmPerDegreeFahrenheit(double ppmperdegreefahrenheit)
         {
-            double value = (double) ppmperdegreefahrenheit;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
+            return new CoefficientOfThermalExpansion(ppmperdegreefahrenheit, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPpmPerKelvin(QuantityValue ppmperkelvin)
+        public static CoefficientOfThermalExpansion FromPpmPerKelvin(double ppmperkelvin)
         {
-            double value = (double) ppmperkelvin;
-            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerKelvin);
+            return new CoefficientOfThermalExpansion(ppmperkelvin, CoefficientOfThermalExpansionUnit.PpmPerKelvin);
         }
 
         /// <summary>
@@ -389,9 +380,9 @@ public static CoefficientOfThermalExpansion FromPpmPerKelvin(QuantityValue ppmpe
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>CoefficientOfThermalExpansion unit value.</returns>
-        public static CoefficientOfThermalExpansion From(QuantityValue value, CoefficientOfThermalExpansionUnit fromUnit)
+        public static CoefficientOfThermalExpansion From(double value, CoefficientOfThermalExpansionUnit fromUnit)
         {
-            return new CoefficientOfThermalExpansion((double)value, fromUnit);
+            return new CoefficientOfThermalExpansion(value, fromUnit);
         }
 
         #endregion
@@ -812,15 +803,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is CoefficientOfThermalExpansionUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CoefficientOfThermalExpansionUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is CoefficientOfThermalExpansionUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CoefficientOfThermalExpansionUnit)} is supported.", nameof(unit));
@@ -951,18 +933,6 @@ public CoefficientOfThermalExpansion ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<CoefficientOfThermalExpansionUnit> IQuantity<CoefficientOfThermalExpansionUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not CoefficientOfThermalExpansionUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CoefficientOfThermalExpansionUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
index 8c4f3b14c2..c0dd43106d 100644
--- a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Compressibility :
-        IArithmeticQuantity<Compressibility, CompressibilityUnit, double>,
+        IArithmeticQuantity<Compressibility, CompressibilityUnit>,
         IComparable,
         IComparable<Compressibility>,
         IConvertible,
@@ -153,7 +153,7 @@ public Compressibility(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -269,70 +269,63 @@ public static string GetAbbreviation(CompressibilityUnit unit, IFormatProvider?
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseAtmosphere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseAtmospheres(QuantityValue inverseatmospheres)
+        public static Compressibility FromInverseAtmospheres(double inverseatmospheres)
         {
-            double value = (double) inverseatmospheres;
-            return new Compressibility(value, CompressibilityUnit.InverseAtmosphere);
+            return new Compressibility(inverseatmospheres, CompressibilityUnit.InverseAtmosphere);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseBar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseBars(QuantityValue inversebars)
+        public static Compressibility FromInverseBars(double inversebars)
         {
-            double value = (double) inversebars;
-            return new Compressibility(value, CompressibilityUnit.InverseBar);
+            return new Compressibility(inversebars, CompressibilityUnit.InverseBar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseKilopascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseKilopascals(QuantityValue inversekilopascals)
+        public static Compressibility FromInverseKilopascals(double inversekilopascals)
         {
-            double value = (double) inversekilopascals;
-            return new Compressibility(value, CompressibilityUnit.InverseKilopascal);
+            return new Compressibility(inversekilopascals, CompressibilityUnit.InverseKilopascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseMegapascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseMegapascals(QuantityValue inversemegapascals)
+        public static Compressibility FromInverseMegapascals(double inversemegapascals)
         {
-            double value = (double) inversemegapascals;
-            return new Compressibility(value, CompressibilityUnit.InverseMegapascal);
+            return new Compressibility(inversemegapascals, CompressibilityUnit.InverseMegapascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseMillibar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseMillibars(QuantityValue inversemillibars)
+        public static Compressibility FromInverseMillibars(double inversemillibars)
         {
-            double value = (double) inversemillibars;
-            return new Compressibility(value, CompressibilityUnit.InverseMillibar);
+            return new Compressibility(inversemillibars, CompressibilityUnit.InverseMillibar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InversePascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInversePascals(QuantityValue inversepascals)
+        public static Compressibility FromInversePascals(double inversepascals)
         {
-            double value = (double) inversepascals;
-            return new Compressibility(value, CompressibilityUnit.InversePascal);
+            return new Compressibility(inversepascals, CompressibilityUnit.InversePascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InversePoundForcePerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInversePoundsForcePerSquareInch(QuantityValue inversepoundsforcepersquareinch)
+        public static Compressibility FromInversePoundsForcePerSquareInch(double inversepoundsforcepersquareinch)
         {
-            double value = (double) inversepoundsforcepersquareinch;
-            return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch);
+            return new Compressibility(inversepoundsforcepersquareinch, CompressibilityUnit.InversePoundForcePerSquareInch);
         }
 
         /// <summary>
@@ -341,9 +334,9 @@ public static Compressibility FromInversePoundsForcePerSquareInch(QuantityValue
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Compressibility unit value.</returns>
-        public static Compressibility From(QuantityValue value, CompressibilityUnit fromUnit)
+        public static Compressibility From(double value, CompressibilityUnit fromUnit)
         {
-            return new Compressibility((double)value, fromUnit);
+            return new Compressibility(value, fromUnit);
         }
 
         #endregion
@@ -754,15 +747,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is CompressibilityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CompressibilityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is CompressibilityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CompressibilityUnit)} is supported.", nameof(unit));
@@ -889,18 +873,6 @@ public Compressibility ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<CompressibilityUnit> IQuantity<CompressibilityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not CompressibilityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(CompressibilityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
index 4c46483364..f0760bf017 100644
--- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Density :
-        IArithmeticQuantity<Density, DensityUnit, double>,
+        IArithmeticQuantity<Density, DensityUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Density, KinematicViscosity, DynamicViscosity>,
         IMultiplyOperators<Density, Area, LinearDensity>,
@@ -217,7 +217,7 @@ public Density(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -676,560 +676,504 @@ public static string GetAbbreviation(DensityUnit unit, IFormatProvider? provider
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerDeciliter(QuantityValue centigramsperdeciliter)
+        public static Density FromCentigramsPerDeciliter(double centigramsperdeciliter)
         {
-            double value = (double) centigramsperdeciliter;
-            return new Density(value, DensityUnit.CentigramPerDeciliter);
+            return new Density(centigramsperdeciliter, DensityUnit.CentigramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerLiter(QuantityValue centigramsperliter)
+        public static Density FromCentigramsPerLiter(double centigramsperliter)
         {
-            double value = (double) centigramsperliter;
-            return new Density(value, DensityUnit.CentigramPerLiter);
+            return new Density(centigramsperliter, DensityUnit.CentigramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerMilliliter(QuantityValue centigramspermilliliter)
+        public static Density FromCentigramsPerMilliliter(double centigramspermilliliter)
         {
-            double value = (double) centigramspermilliliter;
-            return new Density(value, DensityUnit.CentigramPerMilliliter);
+            return new Density(centigramspermilliliter, DensityUnit.CentigramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerDeciliter(QuantityValue decigramsperdeciliter)
+        public static Density FromDecigramsPerDeciliter(double decigramsperdeciliter)
         {
-            double value = (double) decigramsperdeciliter;
-            return new Density(value, DensityUnit.DecigramPerDeciliter);
+            return new Density(decigramsperdeciliter, DensityUnit.DecigramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerLiter(QuantityValue decigramsperliter)
+        public static Density FromDecigramsPerLiter(double decigramsperliter)
         {
-            double value = (double) decigramsperliter;
-            return new Density(value, DensityUnit.DecigramPerLiter);
+            return new Density(decigramsperliter, DensityUnit.DecigramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerMilliliter(QuantityValue decigramspermilliliter)
+        public static Density FromDecigramsPerMilliliter(double decigramspermilliliter)
         {
-            double value = (double) decigramspermilliliter;
-            return new Density(value, DensityUnit.DecigramPerMilliliter);
+            return new Density(decigramspermilliliter, DensityUnit.DecigramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromFemtogramsPerDeciliter(QuantityValue femtogramsperdeciliter)
+        public static Density FromFemtogramsPerDeciliter(double femtogramsperdeciliter)
         {
-            double value = (double) femtogramsperdeciliter;
-            return new Density(value, DensityUnit.FemtogramPerDeciliter);
+            return new Density(femtogramsperdeciliter, DensityUnit.FemtogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromFemtogramsPerLiter(QuantityValue femtogramsperliter)
+        public static Density FromFemtogramsPerLiter(double femtogramsperliter)
         {
-            double value = (double) femtogramsperliter;
-            return new Density(value, DensityUnit.FemtogramPerLiter);
+            return new Density(femtogramsperliter, DensityUnit.FemtogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromFemtogramsPerMilliliter(QuantityValue femtogramspermilliliter)
+        public static Density FromFemtogramsPerMilliliter(double femtogramspermilliliter)
         {
-            double value = (double) femtogramspermilliliter;
-            return new Density(value, DensityUnit.FemtogramPerMilliliter);
+            return new Density(femtogramspermilliliter, DensityUnit.FemtogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicCentimeter(QuantityValue gramspercubiccentimeter)
+        public static Density FromGramsPerCubicCentimeter(double gramspercubiccentimeter)
         {
-            double value = (double) gramspercubiccentimeter;
-            return new Density(value, DensityUnit.GramPerCubicCentimeter);
+            return new Density(gramspercubiccentimeter, DensityUnit.GramPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicFoot(QuantityValue gramspercubicfoot)
+        public static Density FromGramsPerCubicFoot(double gramspercubicfoot)
         {
-            double value = (double) gramspercubicfoot;
-            return new Density(value, DensityUnit.GramPerCubicFoot);
+            return new Density(gramspercubicfoot, DensityUnit.GramPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicInch(QuantityValue gramspercubicinch)
+        public static Density FromGramsPerCubicInch(double gramspercubicinch)
         {
-            double value = (double) gramspercubicinch;
-            return new Density(value, DensityUnit.GramPerCubicInch);
+            return new Density(gramspercubicinch, DensityUnit.GramPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicMeter(QuantityValue gramspercubicmeter)
+        public static Density FromGramsPerCubicMeter(double gramspercubicmeter)
         {
-            double value = (double) gramspercubicmeter;
-            return new Density(value, DensityUnit.GramPerCubicMeter);
+            return new Density(gramspercubicmeter, DensityUnit.GramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicMillimeter(QuantityValue gramspercubicmillimeter)
+        public static Density FromGramsPerCubicMillimeter(double gramspercubicmillimeter)
         {
-            double value = (double) gramspercubicmillimeter;
-            return new Density(value, DensityUnit.GramPerCubicMillimeter);
+            return new Density(gramspercubicmillimeter, DensityUnit.GramPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerDeciliter(QuantityValue gramsperdeciliter)
+        public static Density FromGramsPerDeciliter(double gramsperdeciliter)
         {
-            double value = (double) gramsperdeciliter;
-            return new Density(value, DensityUnit.GramPerDeciliter);
+            return new Density(gramsperdeciliter, DensityUnit.GramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerLiter(QuantityValue gramsperliter)
+        public static Density FromGramsPerLiter(double gramsperliter)
         {
-            double value = (double) gramsperliter;
-            return new Density(value, DensityUnit.GramPerLiter);
+            return new Density(gramsperliter, DensityUnit.GramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerMilliliter(QuantityValue gramspermilliliter)
+        public static Density FromGramsPerMilliliter(double gramspermilliliter)
         {
-            double value = (double) gramspermilliliter;
-            return new Density(value, DensityUnit.GramPerMilliliter);
+            return new Density(gramspermilliliter, DensityUnit.GramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicCentimeter(QuantityValue kilogramspercubiccentimeter)
+        public static Density FromKilogramsPerCubicCentimeter(double kilogramspercubiccentimeter)
         {
-            double value = (double) kilogramspercubiccentimeter;
-            return new Density(value, DensityUnit.KilogramPerCubicCentimeter);
+            return new Density(kilogramspercubiccentimeter, DensityUnit.KilogramPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicMeter(QuantityValue kilogramspercubicmeter)
+        public static Density FromKilogramsPerCubicMeter(double kilogramspercubicmeter)
         {
-            double value = (double) kilogramspercubicmeter;
-            return new Density(value, DensityUnit.KilogramPerCubicMeter);
+            return new Density(kilogramspercubicmeter, DensityUnit.KilogramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicMillimeter(QuantityValue kilogramspercubicmillimeter)
+        public static Density FromKilogramsPerCubicMillimeter(double kilogramspercubicmillimeter)
         {
-            double value = (double) kilogramspercubicmillimeter;
-            return new Density(value, DensityUnit.KilogramPerCubicMillimeter);
+            return new Density(kilogramspercubicmillimeter, DensityUnit.KilogramPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerLiter(QuantityValue kilogramsperliter)
+        public static Density FromKilogramsPerLiter(double kilogramsperliter)
         {
-            double value = (double) kilogramsperliter;
-            return new Density(value, DensityUnit.KilogramPerLiter);
+            return new Density(kilogramsperliter, DensityUnit.KilogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilopoundsPerCubicFoot(QuantityValue kilopoundspercubicfoot)
+        public static Density FromKilopoundsPerCubicFoot(double kilopoundspercubicfoot)
         {
-            double value = (double) kilopoundspercubicfoot;
-            return new Density(value, DensityUnit.KilopoundPerCubicFoot);
+            return new Density(kilopoundspercubicfoot, DensityUnit.KilopoundPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilopoundsPerCubicInch(QuantityValue kilopoundspercubicinch)
+        public static Density FromKilopoundsPerCubicInch(double kilopoundspercubicinch)
         {
-            double value = (double) kilopoundspercubicinch;
-            return new Density(value, DensityUnit.KilopoundPerCubicInch);
+            return new Density(kilopoundspercubicinch, DensityUnit.KilopoundPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilopoundsPerCubicYard(QuantityValue kilopoundspercubicyard)
+        public static Density FromKilopoundsPerCubicYard(double kilopoundspercubicyard)
         {
-            double value = (double) kilopoundspercubicyard;
-            return new Density(value, DensityUnit.KilopoundPerCubicYard);
+            return new Density(kilopoundspercubicyard, DensityUnit.KilopoundPerCubicYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerCubicMeter(QuantityValue microgramspercubicmeter)
+        public static Density FromMicrogramsPerCubicMeter(double microgramspercubicmeter)
         {
-            double value = (double) microgramspercubicmeter;
-            return new Density(value, DensityUnit.MicrogramPerCubicMeter);
+            return new Density(microgramspercubicmeter, DensityUnit.MicrogramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerDeciliter(QuantityValue microgramsperdeciliter)
+        public static Density FromMicrogramsPerDeciliter(double microgramsperdeciliter)
         {
-            double value = (double) microgramsperdeciliter;
-            return new Density(value, DensityUnit.MicrogramPerDeciliter);
+            return new Density(microgramsperdeciliter, DensityUnit.MicrogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerLiter(QuantityValue microgramsperliter)
+        public static Density FromMicrogramsPerLiter(double microgramsperliter)
         {
-            double value = (double) microgramsperliter;
-            return new Density(value, DensityUnit.MicrogramPerLiter);
+            return new Density(microgramsperliter, DensityUnit.MicrogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerMilliliter(QuantityValue microgramspermilliliter)
+        public static Density FromMicrogramsPerMilliliter(double microgramspermilliliter)
         {
-            double value = (double) microgramspermilliliter;
-            return new Density(value, DensityUnit.MicrogramPerMilliliter);
+            return new Density(microgramspermilliliter, DensityUnit.MicrogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerCubicMeter(QuantityValue milligramspercubicmeter)
+        public static Density FromMilligramsPerCubicMeter(double milligramspercubicmeter)
         {
-            double value = (double) milligramspercubicmeter;
-            return new Density(value, DensityUnit.MilligramPerCubicMeter);
+            return new Density(milligramspercubicmeter, DensityUnit.MilligramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerDeciliter(QuantityValue milligramsperdeciliter)
+        public static Density FromMilligramsPerDeciliter(double milligramsperdeciliter)
         {
-            double value = (double) milligramsperdeciliter;
-            return new Density(value, DensityUnit.MilligramPerDeciliter);
+            return new Density(milligramsperdeciliter, DensityUnit.MilligramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerLiter(QuantityValue milligramsperliter)
+        public static Density FromMilligramsPerLiter(double milligramsperliter)
         {
-            double value = (double) milligramsperliter;
-            return new Density(value, DensityUnit.MilligramPerLiter);
+            return new Density(milligramsperliter, DensityUnit.MilligramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerMilliliter(QuantityValue milligramspermilliliter)
+        public static Density FromMilligramsPerMilliliter(double milligramspermilliliter)
         {
-            double value = (double) milligramspermilliliter;
-            return new Density(value, DensityUnit.MilligramPerMilliliter);
+            return new Density(milligramspermilliliter, DensityUnit.MilligramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerDeciliter(QuantityValue nanogramsperdeciliter)
+        public static Density FromNanogramsPerDeciliter(double nanogramsperdeciliter)
         {
-            double value = (double) nanogramsperdeciliter;
-            return new Density(value, DensityUnit.NanogramPerDeciliter);
+            return new Density(nanogramsperdeciliter, DensityUnit.NanogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerLiter(QuantityValue nanogramsperliter)
+        public static Density FromNanogramsPerLiter(double nanogramsperliter)
         {
-            double value = (double) nanogramsperliter;
-            return new Density(value, DensityUnit.NanogramPerLiter);
+            return new Density(nanogramsperliter, DensityUnit.NanogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerMilliliter(QuantityValue nanogramspermilliliter)
+        public static Density FromNanogramsPerMilliliter(double nanogramspermilliliter)
         {
-            double value = (double) nanogramspermilliliter;
-            return new Density(value, DensityUnit.NanogramPerMilliliter);
+            return new Density(nanogramspermilliliter, DensityUnit.NanogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerDeciliter(QuantityValue picogramsperdeciliter)
+        public static Density FromPicogramsPerDeciliter(double picogramsperdeciliter)
         {
-            double value = (double) picogramsperdeciliter;
-            return new Density(value, DensityUnit.PicogramPerDeciliter);
+            return new Density(picogramsperdeciliter, DensityUnit.PicogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerLiter(QuantityValue picogramsperliter)
+        public static Density FromPicogramsPerLiter(double picogramsperliter)
         {
-            double value = (double) picogramsperliter;
-            return new Density(value, DensityUnit.PicogramPerLiter);
+            return new Density(picogramsperliter, DensityUnit.PicogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerMilliliter(QuantityValue picogramspermilliliter)
+        public static Density FromPicogramsPerMilliliter(double picogramspermilliliter)
         {
-            double value = (double) picogramspermilliliter;
-            return new Density(value, DensityUnit.PicogramPerMilliliter);
+            return new Density(picogramspermilliliter, DensityUnit.PicogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicCentimeter(QuantityValue poundspercubiccentimeter)
+        public static Density FromPoundsPerCubicCentimeter(double poundspercubiccentimeter)
         {
-            double value = (double) poundspercubiccentimeter;
-            return new Density(value, DensityUnit.PoundPerCubicCentimeter);
+            return new Density(poundspercubiccentimeter, DensityUnit.PoundPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicFoot(QuantityValue poundspercubicfoot)
+        public static Density FromPoundsPerCubicFoot(double poundspercubicfoot)
         {
-            double value = (double) poundspercubicfoot;
-            return new Density(value, DensityUnit.PoundPerCubicFoot);
+            return new Density(poundspercubicfoot, DensityUnit.PoundPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicInch(QuantityValue poundspercubicinch)
+        public static Density FromPoundsPerCubicInch(double poundspercubicinch)
         {
-            double value = (double) poundspercubicinch;
-            return new Density(value, DensityUnit.PoundPerCubicInch);
+            return new Density(poundspercubicinch, DensityUnit.PoundPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicMeter(QuantityValue poundspercubicmeter)
+        public static Density FromPoundsPerCubicMeter(double poundspercubicmeter)
         {
-            double value = (double) poundspercubicmeter;
-            return new Density(value, DensityUnit.PoundPerCubicMeter);
+            return new Density(poundspercubicmeter, DensityUnit.PoundPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicMillimeter(QuantityValue poundspercubicmillimeter)
+        public static Density FromPoundsPerCubicMillimeter(double poundspercubicmillimeter)
         {
-            double value = (double) poundspercubicmillimeter;
-            return new Density(value, DensityUnit.PoundPerCubicMillimeter);
+            return new Density(poundspercubicmillimeter, DensityUnit.PoundPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicYard(QuantityValue poundspercubicyard)
+        public static Density FromPoundsPerCubicYard(double poundspercubicyard)
         {
-            double value = (double) poundspercubicyard;
-            return new Density(value, DensityUnit.PoundPerCubicYard);
+            return new Density(poundspercubicyard, DensityUnit.PoundPerCubicYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerImperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerImperialGallon(QuantityValue poundsperimperialgallon)
+        public static Density FromPoundsPerImperialGallon(double poundsperimperialgallon)
         {
-            double value = (double) poundsperimperialgallon;
-            return new Density(value, DensityUnit.PoundPerImperialGallon);
+            return new Density(poundsperimperialgallon, DensityUnit.PoundPerImperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerUSGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerUSGallon(QuantityValue poundsperusgallon)
+        public static Density FromPoundsPerUSGallon(double poundsperusgallon)
         {
-            double value = (double) poundsperusgallon;
-            return new Density(value, DensityUnit.PoundPerUSGallon);
+            return new Density(poundsperusgallon, DensityUnit.PoundPerUSGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicCentimeter(QuantityValue slugspercubiccentimeter)
+        public static Density FromSlugsPerCubicCentimeter(double slugspercubiccentimeter)
         {
-            double value = (double) slugspercubiccentimeter;
-            return new Density(value, DensityUnit.SlugPerCubicCentimeter);
+            return new Density(slugspercubiccentimeter, DensityUnit.SlugPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicFoot(QuantityValue slugspercubicfoot)
+        public static Density FromSlugsPerCubicFoot(double slugspercubicfoot)
         {
-            double value = (double) slugspercubicfoot;
-            return new Density(value, DensityUnit.SlugPerCubicFoot);
+            return new Density(slugspercubicfoot, DensityUnit.SlugPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicInch(QuantityValue slugspercubicinch)
+        public static Density FromSlugsPerCubicInch(double slugspercubicinch)
         {
-            double value = (double) slugspercubicinch;
-            return new Density(value, DensityUnit.SlugPerCubicInch);
+            return new Density(slugspercubicinch, DensityUnit.SlugPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicMeter(QuantityValue slugspercubicmeter)
+        public static Density FromSlugsPerCubicMeter(double slugspercubicmeter)
         {
-            double value = (double) slugspercubicmeter;
-            return new Density(value, DensityUnit.SlugPerCubicMeter);
+            return new Density(slugspercubicmeter, DensityUnit.SlugPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicMillimeter(QuantityValue slugspercubicmillimeter)
+        public static Density FromSlugsPerCubicMillimeter(double slugspercubicmillimeter)
         {
-            double value = (double) slugspercubicmillimeter;
-            return new Density(value, DensityUnit.SlugPerCubicMillimeter);
+            return new Density(slugspercubicmillimeter, DensityUnit.SlugPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicCentimeter(QuantityValue tonnespercubiccentimeter)
+        public static Density FromTonnesPerCubicCentimeter(double tonnespercubiccentimeter)
         {
-            double value = (double) tonnespercubiccentimeter;
-            return new Density(value, DensityUnit.TonnePerCubicCentimeter);
+            return new Density(tonnespercubiccentimeter, DensityUnit.TonnePerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicFoot(QuantityValue tonnespercubicfoot)
+        public static Density FromTonnesPerCubicFoot(double tonnespercubicfoot)
         {
-            double value = (double) tonnespercubicfoot;
-            return new Density(value, DensityUnit.TonnePerCubicFoot);
+            return new Density(tonnespercubicfoot, DensityUnit.TonnePerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicInch(QuantityValue tonnespercubicinch)
+        public static Density FromTonnesPerCubicInch(double tonnespercubicinch)
         {
-            double value = (double) tonnespercubicinch;
-            return new Density(value, DensityUnit.TonnePerCubicInch);
+            return new Density(tonnespercubicinch, DensityUnit.TonnePerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicMeter(QuantityValue tonnespercubicmeter)
+        public static Density FromTonnesPerCubicMeter(double tonnespercubicmeter)
         {
-            double value = (double) tonnespercubicmeter;
-            return new Density(value, DensityUnit.TonnePerCubicMeter);
+            return new Density(tonnespercubicmeter, DensityUnit.TonnePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicMillimeter(QuantityValue tonnespercubicmillimeter)
+        public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimeter)
         {
-            double value = (double) tonnespercubicmillimeter;
-            return new Density(value, DensityUnit.TonnePerCubicMillimeter);
+            return new Density(tonnespercubicmillimeter, DensityUnit.TonnePerCubicMillimeter);
         }
 
         /// <summary>
@@ -1238,9 +1182,9 @@ public static Density FromTonnesPerCubicMillimeter(QuantityValue tonnespercubicm
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Density unit value.</returns>
-        public static Density From(QuantityValue value, DensityUnit fromUnit)
+        public static Density From(double value, DensityUnit fromUnit)
         {
-            return new Density((double)value, fromUnit);
+            return new Density(value, fromUnit);
         }
 
         #endregion
@@ -1697,15 +1641,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is DensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is DensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DensityUnit)} is supported.", nameof(unit));
@@ -1930,18 +1865,6 @@ public Density ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<DensityUnit> IQuantity<DensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not DensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
index 1fd3a70cb4..ed094880bb 100644
--- a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Duration :
-        IArithmeticQuantity<Duration, DurationUnit, double>,
+        IArithmeticQuantity<Duration, DurationUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Duration, MolarFlow, AmountOfSubstance>,
         IMultiplyOperators<Duration, RotationalSpeed, Angle>,
@@ -175,7 +175,7 @@ public Duration(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -319,110 +319,99 @@ public static string GetAbbreviation(DurationUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Day"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromDays(QuantityValue days)
+        public static Duration FromDays(double days)
         {
-            double value = (double) days;
-            return new Duration(value, DurationUnit.Day);
+            return new Duration(days, DurationUnit.Day);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Hour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromHours(QuantityValue hours)
+        public static Duration FromHours(double hours)
         {
-            double value = (double) hours;
-            return new Duration(value, DurationUnit.Hour);
+            return new Duration(hours, DurationUnit.Hour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.JulianYear"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromJulianYears(QuantityValue julianyears)
+        public static Duration FromJulianYears(double julianyears)
         {
-            double value = (double) julianyears;
-            return new Duration(value, DurationUnit.JulianYear);
+            return new Duration(julianyears, DurationUnit.JulianYear);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Microsecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMicroseconds(QuantityValue microseconds)
+        public static Duration FromMicroseconds(double microseconds)
         {
-            double value = (double) microseconds;
-            return new Duration(value, DurationUnit.Microsecond);
+            return new Duration(microseconds, DurationUnit.Microsecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Millisecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMilliseconds(QuantityValue milliseconds)
+        public static Duration FromMilliseconds(double milliseconds)
         {
-            double value = (double) milliseconds;
-            return new Duration(value, DurationUnit.Millisecond);
+            return new Duration(milliseconds, DurationUnit.Millisecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Minute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMinutes(QuantityValue minutes)
+        public static Duration FromMinutes(double minutes)
         {
-            double value = (double) minutes;
-            return new Duration(value, DurationUnit.Minute);
+            return new Duration(minutes, DurationUnit.Minute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Month30"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMonths30(QuantityValue months30)
+        public static Duration FromMonths30(double months30)
         {
-            double value = (double) months30;
-            return new Duration(value, DurationUnit.Month30);
+            return new Duration(months30, DurationUnit.Month30);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Nanosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromNanoseconds(QuantityValue nanoseconds)
+        public static Duration FromNanoseconds(double nanoseconds)
         {
-            double value = (double) nanoseconds;
-            return new Duration(value, DurationUnit.Nanosecond);
+            return new Duration(nanoseconds, DurationUnit.Nanosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Second"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromSeconds(QuantityValue seconds)
+        public static Duration FromSeconds(double seconds)
         {
-            double value = (double) seconds;
-            return new Duration(value, DurationUnit.Second);
+            return new Duration(seconds, DurationUnit.Second);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Week"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromWeeks(QuantityValue weeks)
+        public static Duration FromWeeks(double weeks)
         {
-            double value = (double) weeks;
-            return new Duration(value, DurationUnit.Week);
+            return new Duration(weeks, DurationUnit.Week);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Year365"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromYears365(QuantityValue years365)
+        public static Duration FromYears365(double years365)
         {
-            double value = (double) years365;
-            return new Duration(value, DurationUnit.Year365);
+            return new Duration(years365, DurationUnit.Year365);
         }
 
         /// <summary>
@@ -431,9 +420,9 @@ public static Duration FromYears365(QuantityValue years365)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Duration unit value.</returns>
-        public static Duration From(QuantityValue value, DurationUnit fromUnit)
+        public static Duration From(double value, DurationUnit fromUnit)
         {
-            return new Duration((double)value, fromUnit);
+            return new Duration(value, fromUnit);
         }
 
         #endregion
@@ -926,15 +915,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is DurationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DurationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is DurationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DurationUnit)} is supported.", nameof(unit));
@@ -1069,18 +1049,6 @@ public Duration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<DurationUnit> IQuantity<DurationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not DurationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DurationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
index 79a030503d..982af348d6 100644
--- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct DynamicViscosity :
-        IArithmeticQuantity<DynamicViscosity, DynamicViscosityUnit, double>,
+        IArithmeticQuantity<DynamicViscosity, DynamicViscosityUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<DynamicViscosity, Density, KinematicViscosity>,
 #endif
@@ -165,7 +165,7 @@ public DynamicViscosity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -302,100 +302,90 @@ public static string GetAbbreviation(DynamicViscosityUnit unit, IFormatProvider?
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Centipoise"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromCentipoise(QuantityValue centipoise)
+        public static DynamicViscosity FromCentipoise(double centipoise)
         {
-            double value = (double) centipoise;
-            return new DynamicViscosity(value, DynamicViscosityUnit.Centipoise);
+            return new DynamicViscosity(centipoise, DynamicViscosityUnit.Centipoise);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.MicropascalSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromMicropascalSeconds(QuantityValue micropascalseconds)
+        public static DynamicViscosity FromMicropascalSeconds(double micropascalseconds)
         {
-            double value = (double) micropascalseconds;
-            return new DynamicViscosity(value, DynamicViscosityUnit.MicropascalSecond);
+            return new DynamicViscosity(micropascalseconds, DynamicViscosityUnit.MicropascalSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.MillipascalSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromMillipascalSeconds(QuantityValue millipascalseconds)
+        public static DynamicViscosity FromMillipascalSeconds(double millipascalseconds)
         {
-            double value = (double) millipascalseconds;
-            return new DynamicViscosity(value, DynamicViscosityUnit.MillipascalSecond);
+            return new DynamicViscosity(millipascalseconds, DynamicViscosityUnit.MillipascalSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.NewtonSecondPerMeterSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromNewtonSecondsPerMeterSquared(QuantityValue newtonsecondspermetersquared)
+        public static DynamicViscosity FromNewtonSecondsPerMeterSquared(double newtonsecondspermetersquared)
         {
-            double value = (double) newtonsecondspermetersquared;
-            return new DynamicViscosity(value, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
+            return new DynamicViscosity(newtonsecondspermetersquared, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PascalSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPascalSeconds(QuantityValue pascalseconds)
+        public static DynamicViscosity FromPascalSeconds(double pascalseconds)
         {
-            double value = (double) pascalseconds;
-            return new DynamicViscosity(value, DynamicViscosityUnit.PascalSecond);
+            return new DynamicViscosity(pascalseconds, DynamicViscosityUnit.PascalSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Poise"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoise(QuantityValue poise)
+        public static DynamicViscosity FromPoise(double poise)
         {
-            double value = (double) poise;
-            return new DynamicViscosity(value, DynamicViscosityUnit.Poise);
+            return new DynamicViscosity(poise, DynamicViscosityUnit.Poise);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(QuantityValue poundsforcesecondpersquarefoot)
+        public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(double poundsforcesecondpersquarefoot)
         {
-            double value = (double) poundsforcesecondpersquarefoot;
-            return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
+            return new DynamicViscosity(poundsforcesecondpersquarefoot, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareInch(QuantityValue poundsforcesecondpersquareinch)
+        public static DynamicViscosity FromPoundsForceSecondPerSquareInch(double poundsforcesecondpersquareinch)
         {
-            double value = (double) poundsforcesecondpersquareinch;
-            return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
+            return new DynamicViscosity(poundsforcesecondpersquareinch, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundPerFootSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsPerFootSecond(QuantityValue poundsperfootsecond)
+        public static DynamicViscosity FromPoundsPerFootSecond(double poundsperfootsecond)
         {
-            double value = (double) poundsperfootsecond;
-            return new DynamicViscosity(value, DynamicViscosityUnit.PoundPerFootSecond);
+            return new DynamicViscosity(poundsperfootsecond, DynamicViscosityUnit.PoundPerFootSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Reyn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromReyns(QuantityValue reyns)
+        public static DynamicViscosity FromReyns(double reyns)
         {
-            double value = (double) reyns;
-            return new DynamicViscosity(value, DynamicViscosityUnit.Reyn);
+            return new DynamicViscosity(reyns, DynamicViscosityUnit.Reyn);
         }
 
         /// <summary>
@@ -404,9 +394,9 @@ public static DynamicViscosity FromReyns(QuantityValue reyns)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>DynamicViscosity unit value.</returns>
-        public static DynamicViscosity From(QuantityValue value, DynamicViscosityUnit fromUnit)
+        public static DynamicViscosity From(double value, DynamicViscosityUnit fromUnit)
         {
-            return new DynamicViscosity((double)value, fromUnit);
+            return new DynamicViscosity(value, fromUnit);
         }
 
         #endregion
@@ -827,15 +817,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is DynamicViscosityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DynamicViscosityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is DynamicViscosityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DynamicViscosityUnit)} is supported.", nameof(unit));
@@ -968,18 +949,6 @@ public DynamicViscosity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<DynamicViscosityUnit> IQuantity<DynamicViscosityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not DynamicViscosityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(DynamicViscosityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
index 0751d0f95e..fd7f91d288 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ElectricAdmittance :
-        IArithmeticQuantity<ElectricAdmittance, ElectricAdmittanceUnit, double>,
+        IArithmeticQuantity<ElectricAdmittance, ElectricAdmittanceUnit>,
         IComparable,
         IComparable<ElectricAdmittance>,
         IConvertible,
@@ -150,7 +150,7 @@ public ElectricAdmittance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -245,40 +245,36 @@ public static string GetAbbreviation(ElectricAdmittanceUnit unit, IFormatProvide
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Microsiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromMicrosiemens(QuantityValue microsiemens)
+        public static ElectricAdmittance FromMicrosiemens(double microsiemens)
         {
-            double value = (double) microsiemens;
-            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Microsiemens);
+            return new ElectricAdmittance(microsiemens, ElectricAdmittanceUnit.Microsiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Millisiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromMillisiemens(QuantityValue millisiemens)
+        public static ElectricAdmittance FromMillisiemens(double millisiemens)
         {
-            double value = (double) millisiemens;
-            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millisiemens);
+            return new ElectricAdmittance(millisiemens, ElectricAdmittanceUnit.Millisiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Nanosiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromNanosiemens(QuantityValue nanosiemens)
+        public static ElectricAdmittance FromNanosiemens(double nanosiemens)
         {
-            double value = (double) nanosiemens;
-            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanosiemens);
+            return new ElectricAdmittance(nanosiemens, ElectricAdmittanceUnit.Nanosiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Siemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromSiemens(QuantityValue siemens)
+        public static ElectricAdmittance FromSiemens(double siemens)
         {
-            double value = (double) siemens;
-            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Siemens);
+            return new ElectricAdmittance(siemens, ElectricAdmittanceUnit.Siemens);
         }
 
         /// <summary>
@@ -287,9 +283,9 @@ public static ElectricAdmittance FromSiemens(QuantityValue siemens)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricAdmittance unit value.</returns>
-        public static ElectricAdmittance From(QuantityValue value, ElectricAdmittanceUnit fromUnit)
+        public static ElectricAdmittance From(double value, ElectricAdmittanceUnit fromUnit)
         {
-            return new ElectricAdmittance((double)value, fromUnit);
+            return new ElectricAdmittance(value, fromUnit);
         }
 
         #endregion
@@ -700,15 +696,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricAdmittanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricAdmittanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricAdmittanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricAdmittanceUnit)} is supported.", nameof(unit));
@@ -829,18 +816,6 @@ public ElectricAdmittance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricAdmittanceUnit> IQuantity<ElectricAdmittanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricAdmittanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricAdmittanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
index ea6a9b18f9..dde56c8b82 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricCharge :
-        IArithmeticQuantity<ElectricCharge, ElectricChargeUnit, double>,
+        IArithmeticQuantity<ElectricCharge, ElectricChargeUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<ElectricCharge, ElectricCurrent, Duration>,
         IDivisionOperators<ElectricCharge, Duration, ElectricCurrent>,
@@ -169,7 +169,7 @@ public ElectricCharge(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -313,110 +313,99 @@ public static string GetAbbreviation(ElectricChargeUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.AmpereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromAmpereHours(QuantityValue amperehours)
+        public static ElectricCharge FromAmpereHours(double amperehours)
         {
-            double value = (double) amperehours;
-            return new ElectricCharge(value, ElectricChargeUnit.AmpereHour);
+            return new ElectricCharge(amperehours, ElectricChargeUnit.AmpereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Coulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromCoulombs(QuantityValue coulombs)
+        public static ElectricCharge FromCoulombs(double coulombs)
         {
-            double value = (double) coulombs;
-            return new ElectricCharge(value, ElectricChargeUnit.Coulomb);
+            return new ElectricCharge(coulombs, ElectricChargeUnit.Coulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.KiloampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromKiloampereHours(QuantityValue kiloamperehours)
+        public static ElectricCharge FromKiloampereHours(double kiloamperehours)
         {
-            double value = (double) kiloamperehours;
-            return new ElectricCharge(value, ElectricChargeUnit.KiloampereHour);
+            return new ElectricCharge(kiloamperehours, ElectricChargeUnit.KiloampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Kilocoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromKilocoulombs(QuantityValue kilocoulombs)
+        public static ElectricCharge FromKilocoulombs(double kilocoulombs)
         {
-            double value = (double) kilocoulombs;
-            return new ElectricCharge(value, ElectricChargeUnit.Kilocoulomb);
+            return new ElectricCharge(kilocoulombs, ElectricChargeUnit.Kilocoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.MegaampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMegaampereHours(QuantityValue megaamperehours)
+        public static ElectricCharge FromMegaampereHours(double megaamperehours)
         {
-            double value = (double) megaamperehours;
-            return new ElectricCharge(value, ElectricChargeUnit.MegaampereHour);
+            return new ElectricCharge(megaamperehours, ElectricChargeUnit.MegaampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Megacoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMegacoulombs(QuantityValue megacoulombs)
+        public static ElectricCharge FromMegacoulombs(double megacoulombs)
         {
-            double value = (double) megacoulombs;
-            return new ElectricCharge(value, ElectricChargeUnit.Megacoulomb);
+            return new ElectricCharge(megacoulombs, ElectricChargeUnit.Megacoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Microcoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMicrocoulombs(QuantityValue microcoulombs)
+        public static ElectricCharge FromMicrocoulombs(double microcoulombs)
         {
-            double value = (double) microcoulombs;
-            return new ElectricCharge(value, ElectricChargeUnit.Microcoulomb);
+            return new ElectricCharge(microcoulombs, ElectricChargeUnit.Microcoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.MilliampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMilliampereHours(QuantityValue milliamperehours)
+        public static ElectricCharge FromMilliampereHours(double milliamperehours)
         {
-            double value = (double) milliamperehours;
-            return new ElectricCharge(value, ElectricChargeUnit.MilliampereHour);
+            return new ElectricCharge(milliamperehours, ElectricChargeUnit.MilliampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Millicoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMillicoulombs(QuantityValue millicoulombs)
+        public static ElectricCharge FromMillicoulombs(double millicoulombs)
         {
-            double value = (double) millicoulombs;
-            return new ElectricCharge(value, ElectricChargeUnit.Millicoulomb);
+            return new ElectricCharge(millicoulombs, ElectricChargeUnit.Millicoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Nanocoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromNanocoulombs(QuantityValue nanocoulombs)
+        public static ElectricCharge FromNanocoulombs(double nanocoulombs)
         {
-            double value = (double) nanocoulombs;
-            return new ElectricCharge(value, ElectricChargeUnit.Nanocoulomb);
+            return new ElectricCharge(nanocoulombs, ElectricChargeUnit.Nanocoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Picocoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromPicocoulombs(QuantityValue picocoulombs)
+        public static ElectricCharge FromPicocoulombs(double picocoulombs)
         {
-            double value = (double) picocoulombs;
-            return new ElectricCharge(value, ElectricChargeUnit.Picocoulomb);
+            return new ElectricCharge(picocoulombs, ElectricChargeUnit.Picocoulomb);
         }
 
         /// <summary>
@@ -425,9 +414,9 @@ public static ElectricCharge FromPicocoulombs(QuantityValue picocoulombs)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCharge unit value.</returns>
-        public static ElectricCharge From(QuantityValue value, ElectricChargeUnit fromUnit)
+        public static ElectricCharge From(double value, ElectricChargeUnit fromUnit)
         {
-            return new ElectricCharge((double)value, fromUnit);
+            return new ElectricCharge(value, fromUnit);
         }
 
         #endregion
@@ -866,15 +855,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricChargeUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricChargeUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeUnit)} is supported.", nameof(unit));
@@ -1009,18 +989,6 @@ public ElectricCharge ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricChargeUnit> IQuantity<ElectricChargeUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricChargeUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
index 899ec712d2..0b7f5315d8 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricChargeDensity :
-        IArithmeticQuantity<ElectricChargeDensity, ElectricChargeDensityUnit, double>,
+        IArithmeticQuantity<ElectricChargeDensity, ElectricChargeDensityUnit>,
         IComparable,
         IComparable<ElectricChargeDensity>,
         IConvertible,
@@ -150,7 +150,7 @@ public ElectricChargeDensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(ElectricChargeDensityUnit unit, IFormatProv
         ///     Creates a <see cref="ElectricChargeDensity"/> from <see cref="ElectricChargeDensityUnit.CoulombPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricChargeDensity FromCoulombsPerCubicMeter(QuantityValue coulombspercubicmeter)
+        public static ElectricChargeDensity FromCoulombsPerCubicMeter(double coulombspercubicmeter)
         {
-            double value = (double) coulombspercubicmeter;
-            return new ElectricChargeDensity(value, ElectricChargeDensityUnit.CoulombPerCubicMeter);
+            return new ElectricChargeDensity(coulombspercubicmeter, ElectricChargeDensityUnit.CoulombPerCubicMeter);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static ElectricChargeDensity FromCoulombsPerCubicMeter(QuantityValue coul
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricChargeDensity unit value.</returns>
-        public static ElectricChargeDensity From(QuantityValue value, ElectricChargeDensityUnit fromUnit)
+        public static ElectricChargeDensity From(double value, ElectricChargeDensityUnit fromUnit)
         {
-            return new ElectricChargeDensity((double)value, fromUnit);
+            return new ElectricChargeDensity(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricChargeDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeDensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricChargeDensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeDensityUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public ElectricChargeDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricChargeDensityUnit> IQuantity<ElectricChargeDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricChargeDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricChargeDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
index d878b4172f..7d3ecf9956 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricConductance :
-        IArithmeticQuantity<ElectricConductance, ElectricConductanceUnit, double>,
+        IArithmeticQuantity<ElectricConductance, ElectricConductanceUnit>,
         IComparable,
         IComparable<ElectricConductance>,
         IConvertible,
@@ -154,7 +154,7 @@ public ElectricConductance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -256,50 +256,45 @@ public static string GetAbbreviation(ElectricConductanceUnit unit, IFormatProvid
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Kilosiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromKilosiemens(QuantityValue kilosiemens)
+        public static ElectricConductance FromKilosiemens(double kilosiemens)
         {
-            double value = (double) kilosiemens;
-            return new ElectricConductance(value, ElectricConductanceUnit.Kilosiemens);
+            return new ElectricConductance(kilosiemens, ElectricConductanceUnit.Kilosiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Microsiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromMicrosiemens(QuantityValue microsiemens)
+        public static ElectricConductance FromMicrosiemens(double microsiemens)
         {
-            double value = (double) microsiemens;
-            return new ElectricConductance(value, ElectricConductanceUnit.Microsiemens);
+            return new ElectricConductance(microsiemens, ElectricConductanceUnit.Microsiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Millisiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromMillisiemens(QuantityValue millisiemens)
+        public static ElectricConductance FromMillisiemens(double millisiemens)
         {
-            double value = (double) millisiemens;
-            return new ElectricConductance(value, ElectricConductanceUnit.Millisiemens);
+            return new ElectricConductance(millisiemens, ElectricConductanceUnit.Millisiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Nanosiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromNanosiemens(QuantityValue nanosiemens)
+        public static ElectricConductance FromNanosiemens(double nanosiemens)
         {
-            double value = (double) nanosiemens;
-            return new ElectricConductance(value, ElectricConductanceUnit.Nanosiemens);
+            return new ElectricConductance(nanosiemens, ElectricConductanceUnit.Nanosiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Siemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromSiemens(QuantityValue siemens)
+        public static ElectricConductance FromSiemens(double siemens)
         {
-            double value = (double) siemens;
-            return new ElectricConductance(value, ElectricConductanceUnit.Siemens);
+            return new ElectricConductance(siemens, ElectricConductanceUnit.Siemens);
         }
 
         /// <summary>
@@ -308,9 +303,9 @@ public static ElectricConductance FromSiemens(QuantityValue siemens)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricConductance unit value.</returns>
-        public static ElectricConductance From(QuantityValue value, ElectricConductanceUnit fromUnit)
+        public static ElectricConductance From(double value, ElectricConductanceUnit fromUnit)
         {
-            return new ElectricConductance((double)value, fromUnit);
+            return new ElectricConductance(value, fromUnit);
         }
 
         #endregion
@@ -721,15 +716,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricConductanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricConductanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductanceUnit)} is supported.", nameof(unit));
@@ -852,18 +838,6 @@ public ElectricConductance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricConductanceUnit> IQuantity<ElectricConductanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricConductanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
index d219a0ad7a..778999e06a 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricConductivity :
-        IArithmeticQuantity<ElectricConductivity, ElectricConductivityUnit, double>,
+        IArithmeticQuantity<ElectricConductivity, ElectricConductivityUnit>,
         IComparable,
         IComparable<ElectricConductivity>,
         IConvertible,
@@ -155,7 +155,7 @@ public ElectricConductivity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -264,60 +264,54 @@ public static string GetAbbreviation(ElectricConductivityUnit unit, IFormatProvi
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.MicrosiemensPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromMicrosiemensPerCentimeter(QuantityValue microsiemenspercentimeter)
+        public static ElectricConductivity FromMicrosiemensPerCentimeter(double microsiemenspercentimeter)
         {
-            double value = (double) microsiemenspercentimeter;
-            return new ElectricConductivity(value, ElectricConductivityUnit.MicrosiemensPerCentimeter);
+            return new ElectricConductivity(microsiemenspercentimeter, ElectricConductivityUnit.MicrosiemensPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.MillisiemensPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromMillisiemensPerCentimeter(QuantityValue millisiemenspercentimeter)
+        public static ElectricConductivity FromMillisiemensPerCentimeter(double millisiemenspercentimeter)
         {
-            double value = (double) millisiemenspercentimeter;
-            return new ElectricConductivity(value, ElectricConductivityUnit.MillisiemensPerCentimeter);
+            return new ElectricConductivity(millisiemenspercentimeter, ElectricConductivityUnit.MillisiemensPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerCentimeter(QuantityValue siemenspercentimeter)
+        public static ElectricConductivity FromSiemensPerCentimeter(double siemenspercentimeter)
         {
-            double value = (double) siemenspercentimeter;
-            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerCentimeter);
+            return new ElectricConductivity(siemenspercentimeter, ElectricConductivityUnit.SiemensPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerFoot(QuantityValue siemensperfoot)
+        public static ElectricConductivity FromSiemensPerFoot(double siemensperfoot)
         {
-            double value = (double) siemensperfoot;
-            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerFoot);
+            return new ElectricConductivity(siemensperfoot, ElectricConductivityUnit.SiemensPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerInch(QuantityValue siemensperinch)
+        public static ElectricConductivity FromSiemensPerInch(double siemensperinch)
         {
-            double value = (double) siemensperinch;
-            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerInch);
+            return new ElectricConductivity(siemensperinch, ElectricConductivityUnit.SiemensPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerMeter(QuantityValue siemenspermeter)
+        public static ElectricConductivity FromSiemensPerMeter(double siemenspermeter)
         {
-            double value = (double) siemenspermeter;
-            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerMeter);
+            return new ElectricConductivity(siemenspermeter, ElectricConductivityUnit.SiemensPerMeter);
         }
 
         /// <summary>
@@ -326,9 +320,9 @@ public static ElectricConductivity FromSiemensPerMeter(QuantityValue siemensperm
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricConductivity unit value.</returns>
-        public static ElectricConductivity From(QuantityValue value, ElectricConductivityUnit fromUnit)
+        public static ElectricConductivity From(double value, ElectricConductivityUnit fromUnit)
         {
-            return new ElectricConductivity((double)value, fromUnit);
+            return new ElectricConductivity(value, fromUnit);
         }
 
         #endregion
@@ -750,15 +744,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricConductivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductivityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricConductivityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductivityUnit)} is supported.", nameof(unit));
@@ -883,18 +868,6 @@ public ElectricConductivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricConductivityUnit> IQuantity<ElectricConductivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricConductivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricConductivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
index c54ddcf125..d5760a8a01 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ElectricCurrent :
-        IArithmeticQuantity<ElectricCurrent, ElectricCurrentUnit, double>,
+        IArithmeticQuantity<ElectricCurrent, ElectricCurrentUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<ElectricCurrent, Duration, ElectricCharge>,
         IMultiplyOperators<ElectricCurrent, TimeSpan, ElectricCharge>,
@@ -166,7 +166,7 @@ public ElectricCurrent(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -296,90 +296,81 @@ public static string GetAbbreviation(ElectricCurrentUnit unit, IFormatProvider?
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Ampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromAmperes(QuantityValue amperes)
+        public static ElectricCurrent FromAmperes(double amperes)
         {
-            double value = (double) amperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Ampere);
+            return new ElectricCurrent(amperes, ElectricCurrentUnit.Ampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Centiampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromCentiamperes(QuantityValue centiamperes)
+        public static ElectricCurrent FromCentiamperes(double centiamperes)
         {
-            double value = (double) centiamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Centiampere);
+            return new ElectricCurrent(centiamperes, ElectricCurrentUnit.Centiampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Femtoampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromFemtoamperes(QuantityValue femtoamperes)
+        public static ElectricCurrent FromFemtoamperes(double femtoamperes)
         {
-            double value = (double) femtoamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Femtoampere);
+            return new ElectricCurrent(femtoamperes, ElectricCurrentUnit.Femtoampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Kiloampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromKiloamperes(QuantityValue kiloamperes)
+        public static ElectricCurrent FromKiloamperes(double kiloamperes)
         {
-            double value = (double) kiloamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Kiloampere);
+            return new ElectricCurrent(kiloamperes, ElectricCurrentUnit.Kiloampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Megaampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMegaamperes(QuantityValue megaamperes)
+        public static ElectricCurrent FromMegaamperes(double megaamperes)
         {
-            double value = (double) megaamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Megaampere);
+            return new ElectricCurrent(megaamperes, ElectricCurrentUnit.Megaampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Microampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMicroamperes(QuantityValue microamperes)
+        public static ElectricCurrent FromMicroamperes(double microamperes)
         {
-            double value = (double) microamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Microampere);
+            return new ElectricCurrent(microamperes, ElectricCurrentUnit.Microampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Milliampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMilliamperes(QuantityValue milliamperes)
+        public static ElectricCurrent FromMilliamperes(double milliamperes)
         {
-            double value = (double) milliamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Milliampere);
+            return new ElectricCurrent(milliamperes, ElectricCurrentUnit.Milliampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Nanoampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromNanoamperes(QuantityValue nanoamperes)
+        public static ElectricCurrent FromNanoamperes(double nanoamperes)
         {
-            double value = (double) nanoamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Nanoampere);
+            return new ElectricCurrent(nanoamperes, ElectricCurrentUnit.Nanoampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Picoampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromPicoamperes(QuantityValue picoamperes)
+        public static ElectricCurrent FromPicoamperes(double picoamperes)
         {
-            double value = (double) picoamperes;
-            return new ElectricCurrent(value, ElectricCurrentUnit.Picoampere);
+            return new ElectricCurrent(picoamperes, ElectricCurrentUnit.Picoampere);
         }
 
         /// <summary>
@@ -388,9 +379,9 @@ public static ElectricCurrent FromPicoamperes(QuantityValue picoamperes)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCurrent unit value.</returns>
-        public static ElectricCurrent From(QuantityValue value, ElectricCurrentUnit fromUnit)
+        public static ElectricCurrent From(double value, ElectricCurrentUnit fromUnit)
         {
-            return new ElectricCurrent((double)value, fromUnit);
+            return new ElectricCurrent(value, fromUnit);
         }
 
         #endregion
@@ -847,15 +838,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricCurrentUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricCurrentUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentUnit)} is supported.", nameof(unit));
@@ -986,18 +968,6 @@ public ElectricCurrent ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricCurrentUnit> IQuantity<ElectricCurrentUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricCurrentUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
index bcb73e7de5..5f0f5f3ebe 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricCurrentDensity :
-        IArithmeticQuantity<ElectricCurrentDensity, ElectricCurrentDensityUnit, double>,
+        IArithmeticQuantity<ElectricCurrentDensity, ElectricCurrentDensityUnit>,
         IComparable,
         IComparable<ElectricCurrentDensity>,
         IConvertible,
@@ -152,7 +152,7 @@ public ElectricCurrentDensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -240,30 +240,27 @@ public static string GetAbbreviation(ElectricCurrentDensityUnit unit, IFormatPro
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareFoot(QuantityValue amperespersquarefoot)
+        public static ElectricCurrentDensity FromAmperesPerSquareFoot(double amperespersquarefoot)
         {
-            double value = (double) amperespersquarefoot;
-            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareFoot);
+            return new ElectricCurrentDensity(amperespersquarefoot, ElectricCurrentDensityUnit.AmperePerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareInch(QuantityValue amperespersquareinch)
+        public static ElectricCurrentDensity FromAmperesPerSquareInch(double amperespersquareinch)
         {
-            double value = (double) amperespersquareinch;
-            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareInch);
+            return new ElectricCurrentDensity(amperespersquareinch, ElectricCurrentDensityUnit.AmperePerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareMeter(QuantityValue amperespersquaremeter)
+        public static ElectricCurrentDensity FromAmperesPerSquareMeter(double amperespersquaremeter)
         {
-            double value = (double) amperespersquaremeter;
-            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareMeter);
+            return new ElectricCurrentDensity(amperespersquaremeter, ElectricCurrentDensityUnit.AmperePerSquareMeter);
         }
 
         /// <summary>
@@ -272,9 +269,9 @@ public static ElectricCurrentDensity FromAmperesPerSquareMeter(QuantityValue amp
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCurrentDensity unit value.</returns>
-        public static ElectricCurrentDensity From(QuantityValue value, ElectricCurrentDensityUnit fromUnit)
+        public static ElectricCurrentDensity From(double value, ElectricCurrentDensityUnit fromUnit)
         {
-            return new ElectricCurrentDensity((double)value, fromUnit);
+            return new ElectricCurrentDensity(value, fromUnit);
         }
 
         #endregion
@@ -685,15 +682,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricCurrentDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentDensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricCurrentDensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentDensityUnit)} is supported.", nameof(unit));
@@ -812,18 +800,6 @@ public ElectricCurrentDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricCurrentDensityUnit> IQuantity<ElectricCurrentDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricCurrentDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
index 6683af5fd6..a0715fa4e7 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ElectricCurrentGradient :
-        IArithmeticQuantity<ElectricCurrentGradient, ElectricCurrentGradientUnit, double>,
+        IArithmeticQuantity<ElectricCurrentGradient, ElectricCurrentGradientUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<ElectricCurrentGradient, Duration, ElectricCurrent>,
         IMultiplyOperators<ElectricCurrentGradient, TimeSpan, ElectricCurrent>,
@@ -160,7 +160,7 @@ public ElectricCurrentGradient(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -276,70 +276,63 @@ public static string GetAbbreviation(ElectricCurrentGradientUnit unit, IFormatPr
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerMicrosecond(QuantityValue amperespermicrosecond)
+        public static ElectricCurrentGradient FromAmperesPerMicrosecond(double amperespermicrosecond)
         {
-            double value = (double) amperespermicrosecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMicrosecond);
+            return new ElectricCurrentGradient(amperespermicrosecond, ElectricCurrentGradientUnit.AmperePerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMillisecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerMillisecond(QuantityValue amperespermillisecond)
+        public static ElectricCurrentGradient FromAmperesPerMillisecond(double amperespermillisecond)
         {
-            double value = (double) amperespermillisecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond);
+            return new ElectricCurrentGradient(amperespermillisecond, ElectricCurrentGradientUnit.AmperePerMillisecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerMinute(QuantityValue amperesperminute)
+        public static ElectricCurrentGradient FromAmperesPerMinute(double amperesperminute)
         {
-            double value = (double) amperesperminute;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMinute);
+            return new ElectricCurrentGradient(amperesperminute, ElectricCurrentGradientUnit.AmperePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerNanosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerNanosecond(QuantityValue amperespernanosecond)
+        public static ElectricCurrentGradient FromAmperesPerNanosecond(double amperespernanosecond)
         {
-            double value = (double) amperespernanosecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerNanosecond);
+            return new ElectricCurrentGradient(amperespernanosecond, ElectricCurrentGradientUnit.AmperePerNanosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerSecond(QuantityValue amperespersecond)
+        public static ElectricCurrentGradient FromAmperesPerSecond(double amperespersecond)
         {
-            double value = (double) amperespersecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond);
+            return new ElectricCurrentGradient(amperespersecond, ElectricCurrentGradientUnit.AmperePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.MilliamperePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromMilliamperesPerMinute(QuantityValue milliamperesperminute)
+        public static ElectricCurrentGradient FromMilliamperesPerMinute(double milliamperesperminute)
         {
-            double value = (double) milliamperesperminute;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.MilliamperePerMinute);
+            return new ElectricCurrentGradient(milliamperesperminute, ElectricCurrentGradientUnit.MilliamperePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.MilliamperePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromMilliamperesPerSecond(QuantityValue milliamperespersecond)
+        public static ElectricCurrentGradient FromMilliamperesPerSecond(double milliamperespersecond)
         {
-            double value = (double) milliamperespersecond;
-            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.MilliamperePerSecond);
+            return new ElectricCurrentGradient(milliamperespersecond, ElectricCurrentGradientUnit.MilliamperePerSecond);
         }
 
         /// <summary>
@@ -348,9 +341,9 @@ public static ElectricCurrentGradient FromMilliamperesPerSecond(QuantityValue mi
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricCurrentGradient unit value.</returns>
-        public static ElectricCurrentGradient From(QuantityValue value, ElectricCurrentGradientUnit fromUnit)
+        public static ElectricCurrentGradient From(double value, ElectricCurrentGradientUnit fromUnit)
         {
-            return new ElectricCurrentGradient((double)value, fromUnit);
+            return new ElectricCurrentGradient(value, fromUnit);
         }
 
         #endregion
@@ -783,15 +776,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricCurrentGradientUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentGradientUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricCurrentGradientUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentGradientUnit)} is supported.", nameof(unit));
@@ -918,18 +902,6 @@ public ElectricCurrentGradient ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricCurrentGradientUnit> IQuantity<ElectricCurrentGradientUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricCurrentGradientUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricCurrentGradientUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
index e45c3a2be9..1d73e8c481 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricField :
-        IArithmeticQuantity<ElectricField, ElectricFieldUnit, double>,
+        IArithmeticQuantity<ElectricField, ElectricFieldUnit>,
         IComparable,
         IComparable<ElectricField>,
         IConvertible,
@@ -150,7 +150,7 @@ public ElectricField(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(ElectricFieldUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="ElectricField"/> from <see cref="ElectricFieldUnit.VoltPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricField FromVoltsPerMeter(QuantityValue voltspermeter)
+        public static ElectricField FromVoltsPerMeter(double voltspermeter)
         {
-            double value = (double) voltspermeter;
-            return new ElectricField(value, ElectricFieldUnit.VoltPerMeter);
+            return new ElectricField(voltspermeter, ElectricFieldUnit.VoltPerMeter);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static ElectricField FromVoltsPerMeter(QuantityValue voltspermeter)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricField unit value.</returns>
-        public static ElectricField From(QuantityValue value, ElectricFieldUnit fromUnit)
+        public static ElectricField From(double value, ElectricFieldUnit fromUnit)
         {
-            return new ElectricField((double)value, fromUnit);
+            return new ElectricField(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricFieldUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricFieldUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricFieldUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricFieldUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public ElectricField ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricFieldUnit> IQuantity<ElectricFieldUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricFieldUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricFieldUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
index 3d95a66431..cef87cde96 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricInductance :
-        IArithmeticQuantity<ElectricInductance, ElectricInductanceUnit, double>,
+        IArithmeticQuantity<ElectricInductance, ElectricInductanceUnit>,
         IComparable,
         IComparable<ElectricInductance>,
         IConvertible,
@@ -154,7 +154,7 @@ public ElectricInductance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -256,50 +256,45 @@ public static string GetAbbreviation(ElectricInductanceUnit unit, IFormatProvide
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Henry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromHenries(QuantityValue henries)
+        public static ElectricInductance FromHenries(double henries)
         {
-            double value = (double) henries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Henry);
+            return new ElectricInductance(henries, ElectricInductanceUnit.Henry);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Microhenry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromMicrohenries(QuantityValue microhenries)
+        public static ElectricInductance FromMicrohenries(double microhenries)
         {
-            double value = (double) microhenries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Microhenry);
+            return new ElectricInductance(microhenries, ElectricInductanceUnit.Microhenry);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Millihenry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromMillihenries(QuantityValue millihenries)
+        public static ElectricInductance FromMillihenries(double millihenries)
         {
-            double value = (double) millihenries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Millihenry);
+            return new ElectricInductance(millihenries, ElectricInductanceUnit.Millihenry);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Nanohenry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromNanohenries(QuantityValue nanohenries)
+        public static ElectricInductance FromNanohenries(double nanohenries)
         {
-            double value = (double) nanohenries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry);
+            return new ElectricInductance(nanohenries, ElectricInductanceUnit.Nanohenry);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Picohenry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromPicohenries(QuantityValue picohenries)
+        public static ElectricInductance FromPicohenries(double picohenries)
         {
-            double value = (double) picohenries;
-            return new ElectricInductance(value, ElectricInductanceUnit.Picohenry);
+            return new ElectricInductance(picohenries, ElectricInductanceUnit.Picohenry);
         }
 
         /// <summary>
@@ -308,9 +303,9 @@ public static ElectricInductance FromPicohenries(QuantityValue picohenries)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricInductance unit value.</returns>
-        public static ElectricInductance From(QuantityValue value, ElectricInductanceUnit fromUnit)
+        public static ElectricInductance From(double value, ElectricInductanceUnit fromUnit)
         {
-            return new ElectricInductance((double)value, fromUnit);
+            return new ElectricInductance(value, fromUnit);
         }
 
         #endregion
@@ -721,15 +716,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricInductanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricInductanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricInductanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricInductanceUnit)} is supported.", nameof(unit));
@@ -852,18 +838,6 @@ public ElectricInductance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricInductanceUnit> IQuantity<ElectricInductanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricInductanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricInductanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
index d91a44ff8a..0fd783a39a 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ElectricPotential :
-        IArithmeticQuantity<ElectricPotential, ElectricPotentialUnit, double>,
+        IArithmeticQuantity<ElectricPotential, ElectricPotentialUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<ElectricPotential, ElectricResistance, ElectricCurrent>,
         IDivisionOperators<ElectricPotential, ElectricCurrent, ElectricResistance>,
@@ -161,7 +161,7 @@ public ElectricPotential(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -270,60 +270,54 @@ public static string GetAbbreviation(ElectricPotentialUnit unit, IFormatProvider
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Kilovolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromKilovolts(QuantityValue kilovolts)
+        public static ElectricPotential FromKilovolts(double kilovolts)
         {
-            double value = (double) kilovolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Kilovolt);
+            return new ElectricPotential(kilovolts, ElectricPotentialUnit.Kilovolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Megavolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMegavolts(QuantityValue megavolts)
+        public static ElectricPotential FromMegavolts(double megavolts)
         {
-            double value = (double) megavolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Megavolt);
+            return new ElectricPotential(megavolts, ElectricPotentialUnit.Megavolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Microvolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMicrovolts(QuantityValue microvolts)
+        public static ElectricPotential FromMicrovolts(double microvolts)
         {
-            double value = (double) microvolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Microvolt);
+            return new ElectricPotential(microvolts, ElectricPotentialUnit.Microvolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Millivolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMillivolts(QuantityValue millivolts)
+        public static ElectricPotential FromMillivolts(double millivolts)
         {
-            double value = (double) millivolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Millivolt);
+            return new ElectricPotential(millivolts, ElectricPotentialUnit.Millivolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Nanovolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromNanovolts(QuantityValue nanovolts)
+        public static ElectricPotential FromNanovolts(double nanovolts)
         {
-            double value = (double) nanovolts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Nanovolt);
+            return new ElectricPotential(nanovolts, ElectricPotentialUnit.Nanovolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Volt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromVolts(QuantityValue volts)
+        public static ElectricPotential FromVolts(double volts)
         {
-            double value = (double) volts;
-            return new ElectricPotential(value, ElectricPotentialUnit.Volt);
+            return new ElectricPotential(volts, ElectricPotentialUnit.Volt);
         }
 
         /// <summary>
@@ -332,9 +326,9 @@ public static ElectricPotential FromVolts(QuantityValue volts)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricPotential unit value.</returns>
-        public static ElectricPotential From(QuantityValue value, ElectricPotentialUnit fromUnit)
+        public static ElectricPotential From(double value, ElectricPotentialUnit fromUnit)
         {
-            return new ElectricPotential((double)value, fromUnit);
+            return new ElectricPotential(value, fromUnit);
         }
 
         #endregion
@@ -773,15 +767,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricPotentialUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricPotentialUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialUnit)} is supported.", nameof(unit));
@@ -906,18 +891,6 @@ public ElectricPotential ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricPotentialUnit> IQuantity<ElectricPotentialUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricPotentialUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
index 1570d3641f..529a67a34c 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ElectricPotentialAc :
-        IArithmeticQuantity<ElectricPotentialAc, ElectricPotentialAcUnit, double>,
+        IArithmeticQuantity<ElectricPotentialAc, ElectricPotentialAcUnit>,
         IComparable,
         IComparable<ElectricPotentialAc>,
         IConvertible,
@@ -151,7 +151,7 @@ public ElectricPotentialAc(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -253,50 +253,45 @@ public static string GetAbbreviation(ElectricPotentialAcUnit unit, IFormatProvid
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.KilovoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromKilovoltsAc(QuantityValue kilovoltsac)
+        public static ElectricPotentialAc FromKilovoltsAc(double kilovoltsac)
         {
-            double value = (double) kilovoltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.KilovoltAc);
+            return new ElectricPotentialAc(kilovoltsac, ElectricPotentialAcUnit.KilovoltAc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.MegavoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMegavoltsAc(QuantityValue megavoltsac)
+        public static ElectricPotentialAc FromMegavoltsAc(double megavoltsac)
         {
-            double value = (double) megavoltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MegavoltAc);
+            return new ElectricPotentialAc(megavoltsac, ElectricPotentialAcUnit.MegavoltAc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.MicrovoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMicrovoltsAc(QuantityValue microvoltsac)
+        public static ElectricPotentialAc FromMicrovoltsAc(double microvoltsac)
         {
-            double value = (double) microvoltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MicrovoltAc);
+            return new ElectricPotentialAc(microvoltsac, ElectricPotentialAcUnit.MicrovoltAc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.MillivoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMillivoltsAc(QuantityValue millivoltsac)
+        public static ElectricPotentialAc FromMillivoltsAc(double millivoltsac)
         {
-            double value = (double) millivoltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MillivoltAc);
+            return new ElectricPotentialAc(millivoltsac, ElectricPotentialAcUnit.MillivoltAc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.VoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromVoltsAc(QuantityValue voltsac)
+        public static ElectricPotentialAc FromVoltsAc(double voltsac)
         {
-            double value = (double) voltsac;
-            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.VoltAc);
+            return new ElectricPotentialAc(voltsac, ElectricPotentialAcUnit.VoltAc);
         }
 
         /// <summary>
@@ -305,9 +300,9 @@ public static ElectricPotentialAc FromVoltsAc(QuantityValue voltsac)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricPotentialAc unit value.</returns>
-        public static ElectricPotentialAc From(QuantityValue value, ElectricPotentialAcUnit fromUnit)
+        public static ElectricPotentialAc From(double value, ElectricPotentialAcUnit fromUnit)
         {
-            return new ElectricPotentialAc((double)value, fromUnit);
+            return new ElectricPotentialAc(value, fromUnit);
         }
 
         #endregion
@@ -718,15 +713,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricPotentialAcUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialAcUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricPotentialAcUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialAcUnit)} is supported.", nameof(unit));
@@ -849,18 +835,6 @@ public ElectricPotentialAc ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricPotentialAcUnit> IQuantity<ElectricPotentialAcUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricPotentialAcUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialAcUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
index dad55ac038..876ccd5ebf 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ElectricPotentialChangeRate :
-        IArithmeticQuantity<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit, double>,
+        IArithmeticQuantity<ElectricPotentialChangeRate, ElectricPotentialChangeRateUnit>,
         IComparable,
         IComparable<ElectricPotentialChangeRate>,
         IConvertible,
@@ -166,7 +166,7 @@ public ElectricPotentialChangeRate(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -373,200 +373,180 @@ public static string GetAbbreviation(ElectricPotentialChangeRateUnit unit, IForm
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerHour(QuantityValue kilovoltsperhour)
+        public static ElectricPotentialChangeRate FromKilovoltsPerHour(double kilovoltsperhour)
         {
-            double value = (double) kilovoltsperhour;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour);
+            return new ElectricPotentialChangeRate(kilovoltsperhour, ElectricPotentialChangeRateUnit.KilovoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(QuantityValue kilovoltspermicrosecond)
+        public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(double kilovoltspermicrosecond)
         {
-            double value = (double) kilovoltspermicrosecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(kilovoltspermicrosecond, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMinute(QuantityValue kilovoltsperminute)
+        public static ElectricPotentialChangeRate FromKilovoltsPerMinute(double kilovoltsperminute)
         {
-            double value = (double) kilovoltsperminute;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
+            return new ElectricPotentialChangeRate(kilovoltsperminute, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerSecond(QuantityValue kilovoltspersecond)
+        public static ElectricPotentialChangeRate FromKilovoltsPerSecond(double kilovoltspersecond)
         {
-            double value = (double) kilovoltspersecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
+            return new ElectricPotentialChangeRate(kilovoltspersecond, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerHour(QuantityValue megavoltsperhour)
+        public static ElectricPotentialChangeRate FromMegavoltsPerHour(double megavoltsperhour)
         {
-            double value = (double) megavoltsperhour;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour);
+            return new ElectricPotentialChangeRate(megavoltsperhour, ElectricPotentialChangeRateUnit.MegavoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(QuantityValue megavoltspermicrosecond)
+        public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(double megavoltspermicrosecond)
         {
-            double value = (double) megavoltspermicrosecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(megavoltspermicrosecond, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMinute(QuantityValue megavoltsperminute)
+        public static ElectricPotentialChangeRate FromMegavoltsPerMinute(double megavoltsperminute)
         {
-            double value = (double) megavoltsperminute;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
+            return new ElectricPotentialChangeRate(megavoltsperminute, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerSecond(QuantityValue megavoltspersecond)
+        public static ElectricPotentialChangeRate FromMegavoltsPerSecond(double megavoltspersecond)
         {
-            double value = (double) megavoltspersecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
+            return new ElectricPotentialChangeRate(megavoltspersecond, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerHour(QuantityValue microvoltsperhour)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerHour(double microvoltsperhour)
         {
-            double value = (double) microvoltsperhour;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
+            return new ElectricPotentialChangeRate(microvoltsperhour, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(QuantityValue microvoltspermicrosecond)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(double microvoltspermicrosecond)
         {
-            double value = (double) microvoltspermicrosecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(microvoltspermicrosecond, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(QuantityValue microvoltsperminute)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(double microvoltsperminute)
         {
-            double value = (double) microvoltsperminute;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
+            return new ElectricPotentialChangeRate(microvoltsperminute, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(QuantityValue microvoltspersecond)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(double microvoltspersecond)
         {
-            double value = (double) microvoltspersecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
+            return new ElectricPotentialChangeRate(microvoltspersecond, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerHour(QuantityValue millivoltsperhour)
+        public static ElectricPotentialChangeRate FromMillivoltsPerHour(double millivoltsperhour)
         {
-            double value = (double) millivoltsperhour;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour);
+            return new ElectricPotentialChangeRate(millivoltsperhour, ElectricPotentialChangeRateUnit.MillivoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(QuantityValue millivoltspermicrosecond)
+        public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(double millivoltspermicrosecond)
         {
-            double value = (double) millivoltspermicrosecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(millivoltspermicrosecond, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMinute(QuantityValue millivoltsperminute)
+        public static ElectricPotentialChangeRate FromMillivoltsPerMinute(double millivoltsperminute)
         {
-            double value = (double) millivoltsperminute;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
+            return new ElectricPotentialChangeRate(millivoltsperminute, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerSecond(QuantityValue millivoltspersecond)
+        public static ElectricPotentialChangeRate FromMillivoltsPerSecond(double millivoltspersecond)
         {
-            double value = (double) millivoltspersecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
+            return new ElectricPotentialChangeRate(millivoltspersecond, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerHour(QuantityValue voltsperhour)
+        public static ElectricPotentialChangeRate FromVoltsPerHour(double voltsperhour)
         {
-            double value = (double) voltsperhour;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour);
+            return new ElectricPotentialChangeRate(voltsperhour, ElectricPotentialChangeRateUnit.VoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(QuantityValue voltspermicrosecond)
+        public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(double voltspermicrosecond)
         {
-            double value = (double) voltspermicrosecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(voltspermicrosecond, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerMinute(QuantityValue voltsperminute)
+        public static ElectricPotentialChangeRate FromVoltsPerMinute(double voltsperminute)
         {
-            double value = (double) voltsperminute;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute);
+            return new ElectricPotentialChangeRate(voltsperminute, ElectricPotentialChangeRateUnit.VoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerSecond(QuantityValue voltspersecond)
+        public static ElectricPotentialChangeRate FromVoltsPerSecond(double voltspersecond)
         {
-            double value = (double) voltspersecond;
-            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond);
+            return new ElectricPotentialChangeRate(voltspersecond, ElectricPotentialChangeRateUnit.VoltPerSecond);
         }
 
         /// <summary>
@@ -575,9 +555,9 @@ public static ElectricPotentialChangeRate FromVoltsPerSecond(QuantityValue volts
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricPotentialChangeRate unit value.</returns>
-        public static ElectricPotentialChangeRate From(QuantityValue value, ElectricPotentialChangeRateUnit fromUnit)
+        public static ElectricPotentialChangeRate From(double value, ElectricPotentialChangeRateUnit fromUnit)
         {
-            return new ElectricPotentialChangeRate((double)value, fromUnit);
+            return new ElectricPotentialChangeRate(value, fromUnit);
         }
 
         #endregion
@@ -988,15 +968,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricPotentialChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialChangeRateUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricPotentialChangeRateUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialChangeRateUnit)} is supported.", nameof(unit));
@@ -1149,18 +1120,6 @@ public ElectricPotentialChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricPotentialChangeRateUnit> IQuantity<ElectricPotentialChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricPotentialChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
index 966aa94815..63f8ddc2e6 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ElectricPotentialDc :
-        IArithmeticQuantity<ElectricPotentialDc, ElectricPotentialDcUnit, double>,
+        IArithmeticQuantity<ElectricPotentialDc, ElectricPotentialDcUnit>,
         IComparable,
         IComparable<ElectricPotentialDc>,
         IConvertible,
@@ -151,7 +151,7 @@ public ElectricPotentialDc(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -253,50 +253,45 @@ public static string GetAbbreviation(ElectricPotentialDcUnit unit, IFormatProvid
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.KilovoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromKilovoltsDc(QuantityValue kilovoltsdc)
+        public static ElectricPotentialDc FromKilovoltsDc(double kilovoltsdc)
         {
-            double value = (double) kilovoltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.KilovoltDc);
+            return new ElectricPotentialDc(kilovoltsdc, ElectricPotentialDcUnit.KilovoltDc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.MegavoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMegavoltsDc(QuantityValue megavoltsdc)
+        public static ElectricPotentialDc FromMegavoltsDc(double megavoltsdc)
         {
-            double value = (double) megavoltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MegavoltDc);
+            return new ElectricPotentialDc(megavoltsdc, ElectricPotentialDcUnit.MegavoltDc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.MicrovoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMicrovoltsDc(QuantityValue microvoltsdc)
+        public static ElectricPotentialDc FromMicrovoltsDc(double microvoltsdc)
         {
-            double value = (double) microvoltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MicrovoltDc);
+            return new ElectricPotentialDc(microvoltsdc, ElectricPotentialDcUnit.MicrovoltDc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.MillivoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMillivoltsDc(QuantityValue millivoltsdc)
+        public static ElectricPotentialDc FromMillivoltsDc(double millivoltsdc)
         {
-            double value = (double) millivoltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MillivoltDc);
+            return new ElectricPotentialDc(millivoltsdc, ElectricPotentialDcUnit.MillivoltDc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.VoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromVoltsDc(QuantityValue voltsdc)
+        public static ElectricPotentialDc FromVoltsDc(double voltsdc)
         {
-            double value = (double) voltsdc;
-            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.VoltDc);
+            return new ElectricPotentialDc(voltsdc, ElectricPotentialDcUnit.VoltDc);
         }
 
         /// <summary>
@@ -305,9 +300,9 @@ public static ElectricPotentialDc FromVoltsDc(QuantityValue voltsdc)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricPotentialDc unit value.</returns>
-        public static ElectricPotentialDc From(QuantityValue value, ElectricPotentialDcUnit fromUnit)
+        public static ElectricPotentialDc From(double value, ElectricPotentialDcUnit fromUnit)
         {
-            return new ElectricPotentialDc((double)value, fromUnit);
+            return new ElectricPotentialDc(value, fromUnit);
         }
 
         #endregion
@@ -718,15 +713,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricPotentialDcUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialDcUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricPotentialDcUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialDcUnit)} is supported.", nameof(unit));
@@ -849,18 +835,6 @@ public ElectricPotentialDc ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricPotentialDcUnit> IQuantity<ElectricPotentialDcUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricPotentialDcUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricPotentialDcUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
index 3da018408e..ea9498d3a8 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ElectricResistance :
-        IArithmeticQuantity<ElectricResistance, ElectricResistanceUnit, double>,
+        IArithmeticQuantity<ElectricResistance, ElectricResistanceUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<ElectricResistance, ElectricCurrent, ElectricPotential>,
 #endif
@@ -159,7 +159,7 @@ public ElectricResistance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -275,70 +275,63 @@ public static string GetAbbreviation(ElectricResistanceUnit unit, IFormatProvide
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Gigaohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromGigaohms(QuantityValue gigaohms)
+        public static ElectricResistance FromGigaohms(double gigaohms)
         {
-            double value = (double) gigaohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm);
+            return new ElectricResistance(gigaohms, ElectricResistanceUnit.Gigaohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Kiloohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromKiloohms(QuantityValue kiloohms)
+        public static ElectricResistance FromKiloohms(double kiloohms)
         {
-            double value = (double) kiloohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Kiloohm);
+            return new ElectricResistance(kiloohms, ElectricResistanceUnit.Kiloohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Megaohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMegaohms(QuantityValue megaohms)
+        public static ElectricResistance FromMegaohms(double megaohms)
         {
-            double value = (double) megaohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Megaohm);
+            return new ElectricResistance(megaohms, ElectricResistanceUnit.Megaohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Microohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMicroohms(QuantityValue microohms)
+        public static ElectricResistance FromMicroohms(double microohms)
         {
-            double value = (double) microohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Microohm);
+            return new ElectricResistance(microohms, ElectricResistanceUnit.Microohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Milliohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMilliohms(QuantityValue milliohms)
+        public static ElectricResistance FromMilliohms(double milliohms)
         {
-            double value = (double) milliohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Milliohm);
+            return new ElectricResistance(milliohms, ElectricResistanceUnit.Milliohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Ohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromOhms(QuantityValue ohms)
+        public static ElectricResistance FromOhms(double ohms)
         {
-            double value = (double) ohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Ohm);
+            return new ElectricResistance(ohms, ElectricResistanceUnit.Ohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Teraohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromTeraohms(QuantityValue teraohms)
+        public static ElectricResistance FromTeraohms(double teraohms)
         {
-            double value = (double) teraohms;
-            return new ElectricResistance(value, ElectricResistanceUnit.Teraohm);
+            return new ElectricResistance(teraohms, ElectricResistanceUnit.Teraohm);
         }
 
         /// <summary>
@@ -347,9 +340,9 @@ public static ElectricResistance FromTeraohms(QuantityValue teraohms)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricResistance unit value.</returns>
-        public static ElectricResistance From(QuantityValue value, ElectricResistanceUnit fromUnit)
+        public static ElectricResistance From(double value, ElectricResistanceUnit fromUnit)
         {
-            return new ElectricResistance((double)value, fromUnit);
+            return new ElectricResistance(value, fromUnit);
         }
 
         #endregion
@@ -770,15 +763,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricResistanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricResistanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistanceUnit)} is supported.", nameof(unit));
@@ -905,18 +889,6 @@ public ElectricResistance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricResistanceUnit> IQuantity<ElectricResistanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricResistanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
index 229ecc2f5f..8e569cbc49 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricResistivity :
-        IArithmeticQuantity<ElectricResistivity, ElectricResistivityUnit, double>,
+        IArithmeticQuantity<ElectricResistivity, ElectricResistivityUnit>,
         IComparable,
         IComparable<ElectricResistivity>,
         IConvertible,
@@ -163,7 +163,7 @@ public ElectricResistivity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -328,140 +328,126 @@ public static string GetAbbreviation(ElectricResistivityUnit unit, IFormatProvid
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.KiloohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromKiloohmsCentimeter(QuantityValue kiloohmscentimeter)
+        public static ElectricResistivity FromKiloohmsCentimeter(double kiloohmscentimeter)
         {
-            double value = (double) kiloohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmCentimeter);
+            return new ElectricResistivity(kiloohmscentimeter, ElectricResistivityUnit.KiloohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.KiloohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromKiloohmMeters(QuantityValue kiloohmmeters)
+        public static ElectricResistivity FromKiloohmMeters(double kiloohmmeters)
         {
-            double value = (double) kiloohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmMeter);
+            return new ElectricResistivity(kiloohmmeters, ElectricResistivityUnit.KiloohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MegaohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMegaohmsCentimeter(QuantityValue megaohmscentimeter)
+        public static ElectricResistivity FromMegaohmsCentimeter(double megaohmscentimeter)
         {
-            double value = (double) megaohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmCentimeter);
+            return new ElectricResistivity(megaohmscentimeter, ElectricResistivityUnit.MegaohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MegaohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMegaohmMeters(QuantityValue megaohmmeters)
+        public static ElectricResistivity FromMegaohmMeters(double megaohmmeters)
         {
-            double value = (double) megaohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmMeter);
+            return new ElectricResistivity(megaohmmeters, ElectricResistivityUnit.MegaohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MicroohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMicroohmsCentimeter(QuantityValue microohmscentimeter)
+        public static ElectricResistivity FromMicroohmsCentimeter(double microohmscentimeter)
         {
-            double value = (double) microohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmCentimeter);
+            return new ElectricResistivity(microohmscentimeter, ElectricResistivityUnit.MicroohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MicroohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMicroohmMeters(QuantityValue microohmmeters)
+        public static ElectricResistivity FromMicroohmMeters(double microohmmeters)
         {
-            double value = (double) microohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmMeter);
+            return new ElectricResistivity(microohmmeters, ElectricResistivityUnit.MicroohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MilliohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMilliohmsCentimeter(QuantityValue milliohmscentimeter)
+        public static ElectricResistivity FromMilliohmsCentimeter(double milliohmscentimeter)
         {
-            double value = (double) milliohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmCentimeter);
+            return new ElectricResistivity(milliohmscentimeter, ElectricResistivityUnit.MilliohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MilliohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMilliohmMeters(QuantityValue milliohmmeters)
+        public static ElectricResistivity FromMilliohmMeters(double milliohmmeters)
         {
-            double value = (double) milliohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmMeter);
+            return new ElectricResistivity(milliohmmeters, ElectricResistivityUnit.MilliohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.NanoohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromNanoohmsCentimeter(QuantityValue nanoohmscentimeter)
+        public static ElectricResistivity FromNanoohmsCentimeter(double nanoohmscentimeter)
         {
-            double value = (double) nanoohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmCentimeter);
+            return new ElectricResistivity(nanoohmscentimeter, ElectricResistivityUnit.NanoohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.NanoohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromNanoohmMeters(QuantityValue nanoohmmeters)
+        public static ElectricResistivity FromNanoohmMeters(double nanoohmmeters)
         {
-            double value = (double) nanoohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmMeter);
+            return new ElectricResistivity(nanoohmmeters, ElectricResistivityUnit.NanoohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.OhmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromOhmsCentimeter(QuantityValue ohmscentimeter)
+        public static ElectricResistivity FromOhmsCentimeter(double ohmscentimeter)
         {
-            double value = (double) ohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.OhmCentimeter);
+            return new ElectricResistivity(ohmscentimeter, ElectricResistivityUnit.OhmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.OhmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromOhmMeters(QuantityValue ohmmeters)
+        public static ElectricResistivity FromOhmMeters(double ohmmeters)
         {
-            double value = (double) ohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.OhmMeter);
+            return new ElectricResistivity(ohmmeters, ElectricResistivityUnit.OhmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.PicoohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromPicoohmsCentimeter(QuantityValue picoohmscentimeter)
+        public static ElectricResistivity FromPicoohmsCentimeter(double picoohmscentimeter)
         {
-            double value = (double) picoohmscentimeter;
-            return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmCentimeter);
+            return new ElectricResistivity(picoohmscentimeter, ElectricResistivityUnit.PicoohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.PicoohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromPicoohmMeters(QuantityValue picoohmmeters)
+        public static ElectricResistivity FromPicoohmMeters(double picoohmmeters)
         {
-            double value = (double) picoohmmeters;
-            return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmMeter);
+            return new ElectricResistivity(picoohmmeters, ElectricResistivityUnit.PicoohmMeter);
         }
 
         /// <summary>
@@ -470,9 +456,9 @@ public static ElectricResistivity FromPicoohmMeters(QuantityValue picoohmmeters)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricResistivity unit value.</returns>
-        public static ElectricResistivity From(QuantityValue value, ElectricResistivityUnit fromUnit)
+        public static ElectricResistivity From(double value, ElectricResistivityUnit fromUnit)
         {
-            return new ElectricResistivity((double)value, fromUnit);
+            return new ElectricResistivity(value, fromUnit);
         }
 
         #endregion
@@ -894,15 +880,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricResistivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistivityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricResistivityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistivityUnit)} is supported.", nameof(unit));
@@ -1043,18 +1020,6 @@ public ElectricResistivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricResistivityUnit> IQuantity<ElectricResistivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricResistivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricResistivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
index bab70fe581..0100afc14f 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ElectricSurfaceChargeDensity :
-        IArithmeticQuantity<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit, double>,
+        IArithmeticQuantity<ElectricSurfaceChargeDensity, ElectricSurfaceChargeDensityUnit>,
         IComparable,
         IComparable<ElectricSurfaceChargeDensity>,
         IConvertible,
@@ -152,7 +152,7 @@ public ElectricSurfaceChargeDensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -240,30 +240,27 @@ public static string GetAbbreviation(ElectricSurfaceChargeDensityUnit unit, IFor
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(QuantityValue coulombspersquarecentimeter)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(double coulombspersquarecentimeter)
         {
-            double value = (double) coulombspersquarecentimeter;
-            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
+            return new ElectricSurfaceChargeDensity(coulombspersquarecentimeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(QuantityValue coulombspersquareinch)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(double coulombspersquareinch)
         {
-            double value = (double) coulombspersquareinch;
-            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
+            return new ElectricSurfaceChargeDensity(coulombspersquareinch, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(QuantityValue coulombspersquaremeter)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(double coulombspersquaremeter)
         {
-            double value = (double) coulombspersquaremeter;
-            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
+            return new ElectricSurfaceChargeDensity(coulombspersquaremeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
         }
 
         /// <summary>
@@ -272,9 +269,9 @@ public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(QuantityVa
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ElectricSurfaceChargeDensity unit value.</returns>
-        public static ElectricSurfaceChargeDensity From(QuantityValue value, ElectricSurfaceChargeDensityUnit fromUnit)
+        public static ElectricSurfaceChargeDensity From(double value, ElectricSurfaceChargeDensityUnit fromUnit)
         {
-            return new ElectricSurfaceChargeDensity((double)value, fromUnit);
+            return new ElectricSurfaceChargeDensity(value, fromUnit);
         }
 
         #endregion
@@ -685,15 +682,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ElectricSurfaceChargeDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricSurfaceChargeDensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ElectricSurfaceChargeDensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricSurfaceChargeDensityUnit)} is supported.", nameof(unit));
@@ -812,18 +800,6 @@ public ElectricSurfaceChargeDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ElectricSurfaceChargeDensityUnit> IQuantity<ElectricSurfaceChargeDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ElectricSurfaceChargeDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ElectricSurfaceChargeDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
index 305333c407..b0dc36db32 100644
--- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Energy :
-        IArithmeticQuantity<Energy, EnergyUnit, double>,
+        IArithmeticQuantity<Energy, EnergyUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Energy, Power, Duration>,
         IDivisionOperators<Energy, ElectricPotential, ElectricCharge>,
@@ -201,7 +201,7 @@ public Energy(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -548,400 +548,360 @@ public static string GetAbbreviation(EnergyUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.BritishThermalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromBritishThermalUnits(QuantityValue britishthermalunits)
+        public static Energy FromBritishThermalUnits(double britishthermalunits)
         {
-            double value = (double) britishthermalunits;
-            return new Energy(value, EnergyUnit.BritishThermalUnit);
+            return new Energy(britishthermalunits, EnergyUnit.BritishThermalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Calorie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromCalories(QuantityValue calories)
+        public static Energy FromCalories(double calories)
         {
-            double value = (double) calories;
-            return new Energy(value, EnergyUnit.Calorie);
+            return new Energy(calories, EnergyUnit.Calorie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermEc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsEc(QuantityValue decathermsec)
+        public static Energy FromDecathermsEc(double decathermsec)
         {
-            double value = (double) decathermsec;
-            return new Energy(value, EnergyUnit.DecathermEc);
+            return new Energy(decathermsec, EnergyUnit.DecathermEc);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermImperial"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsImperial(QuantityValue decathermsimperial)
+        public static Energy FromDecathermsImperial(double decathermsimperial)
         {
-            double value = (double) decathermsimperial;
-            return new Energy(value, EnergyUnit.DecathermImperial);
+            return new Energy(decathermsimperial, EnergyUnit.DecathermImperial);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermUs"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsUs(QuantityValue decathermsus)
+        public static Energy FromDecathermsUs(double decathermsus)
         {
-            double value = (double) decathermsus;
-            return new Energy(value, EnergyUnit.DecathermUs);
+            return new Energy(decathermsus, EnergyUnit.DecathermUs);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ElectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromElectronVolts(QuantityValue electronvolts)
+        public static Energy FromElectronVolts(double electronvolts)
         {
-            double value = (double) electronvolts;
-            return new Energy(value, EnergyUnit.ElectronVolt);
+            return new Energy(electronvolts, EnergyUnit.ElectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Erg"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromErgs(QuantityValue ergs)
+        public static Energy FromErgs(double ergs)
         {
-            double value = (double) ergs;
-            return new Energy(value, EnergyUnit.Erg);
+            return new Energy(ergs, EnergyUnit.Erg);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.FootPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromFootPounds(QuantityValue footpounds)
+        public static Energy FromFootPounds(double footpounds)
         {
-            double value = (double) footpounds;
-            return new Energy(value, EnergyUnit.FootPound);
+            return new Energy(footpounds, EnergyUnit.FootPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigabritishThermalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigabritishThermalUnits(QuantityValue gigabritishthermalunits)
+        public static Energy FromGigabritishThermalUnits(double gigabritishthermalunits)
         {
-            double value = (double) gigabritishthermalunits;
-            return new Energy(value, EnergyUnit.GigabritishThermalUnit);
+            return new Energy(gigabritishthermalunits, EnergyUnit.GigabritishThermalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigaelectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigaelectronVolts(QuantityValue gigaelectronvolts)
+        public static Energy FromGigaelectronVolts(double gigaelectronvolts)
         {
-            double value = (double) gigaelectronvolts;
-            return new Energy(value, EnergyUnit.GigaelectronVolt);
+            return new Energy(gigaelectronvolts, EnergyUnit.GigaelectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Gigajoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigajoules(QuantityValue gigajoules)
+        public static Energy FromGigajoules(double gigajoules)
         {
-            double value = (double) gigajoules;
-            return new Energy(value, EnergyUnit.Gigajoule);
+            return new Energy(gigajoules, EnergyUnit.Gigajoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigawattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigawattDays(QuantityValue gigawattdays)
+        public static Energy FromGigawattDays(double gigawattdays)
         {
-            double value = (double) gigawattdays;
-            return new Energy(value, EnergyUnit.GigawattDay);
+            return new Energy(gigawattdays, EnergyUnit.GigawattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigawattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigawattHours(QuantityValue gigawatthours)
+        public static Energy FromGigawattHours(double gigawatthours)
         {
-            double value = (double) gigawatthours;
-            return new Energy(value, EnergyUnit.GigawattHour);
+            return new Energy(gigawatthours, EnergyUnit.GigawattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.HorsepowerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromHorsepowerHours(QuantityValue horsepowerhours)
+        public static Energy FromHorsepowerHours(double horsepowerhours)
         {
-            double value = (double) horsepowerhours;
-            return new Energy(value, EnergyUnit.HorsepowerHour);
+            return new Energy(horsepowerhours, EnergyUnit.HorsepowerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Joule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromJoules(QuantityValue joules)
+        public static Energy FromJoules(double joules)
         {
-            double value = (double) joules;
-            return new Energy(value, EnergyUnit.Joule);
+            return new Energy(joules, EnergyUnit.Joule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilobritishThermalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilobritishThermalUnits(QuantityValue kilobritishthermalunits)
+        public static Energy FromKilobritishThermalUnits(double kilobritishthermalunits)
         {
-            double value = (double) kilobritishthermalunits;
-            return new Energy(value, EnergyUnit.KilobritishThermalUnit);
+            return new Energy(kilobritishthermalunits, EnergyUnit.KilobritishThermalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Kilocalorie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilocalories(QuantityValue kilocalories)
+        public static Energy FromKilocalories(double kilocalories)
         {
-            double value = (double) kilocalories;
-            return new Energy(value, EnergyUnit.Kilocalorie);
+            return new Energy(kilocalories, EnergyUnit.Kilocalorie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KiloelectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKiloelectronVolts(QuantityValue kiloelectronvolts)
+        public static Energy FromKiloelectronVolts(double kiloelectronvolts)
         {
-            double value = (double) kiloelectronvolts;
-            return new Energy(value, EnergyUnit.KiloelectronVolt);
+            return new Energy(kiloelectronvolts, EnergyUnit.KiloelectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Kilojoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilojoules(QuantityValue kilojoules)
+        public static Energy FromKilojoules(double kilojoules)
         {
-            double value = (double) kilojoules;
-            return new Energy(value, EnergyUnit.Kilojoule);
+            return new Energy(kilojoules, EnergyUnit.Kilojoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilowattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilowattDays(QuantityValue kilowattdays)
+        public static Energy FromKilowattDays(double kilowattdays)
         {
-            double value = (double) kilowattdays;
-            return new Energy(value, EnergyUnit.KilowattDay);
+            return new Energy(kilowattdays, EnergyUnit.KilowattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilowattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilowattHours(QuantityValue kilowatthours)
+        public static Energy FromKilowattHours(double kilowatthours)
         {
-            double value = (double) kilowatthours;
-            return new Energy(value, EnergyUnit.KilowattHour);
+            return new Energy(kilowatthours, EnergyUnit.KilowattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegabritishThermalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegabritishThermalUnits(QuantityValue megabritishthermalunits)
+        public static Energy FromMegabritishThermalUnits(double megabritishthermalunits)
         {
-            double value = (double) megabritishthermalunits;
-            return new Energy(value, EnergyUnit.MegabritishThermalUnit);
+            return new Energy(megabritishthermalunits, EnergyUnit.MegabritishThermalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Megacalorie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegacalories(QuantityValue megacalories)
+        public static Energy FromMegacalories(double megacalories)
         {
-            double value = (double) megacalories;
-            return new Energy(value, EnergyUnit.Megacalorie);
+            return new Energy(megacalories, EnergyUnit.Megacalorie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegaelectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegaelectronVolts(QuantityValue megaelectronvolts)
+        public static Energy FromMegaelectronVolts(double megaelectronvolts)
         {
-            double value = (double) megaelectronvolts;
-            return new Energy(value, EnergyUnit.MegaelectronVolt);
+            return new Energy(megaelectronvolts, EnergyUnit.MegaelectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Megajoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegajoules(QuantityValue megajoules)
+        public static Energy FromMegajoules(double megajoules)
         {
-            double value = (double) megajoules;
-            return new Energy(value, EnergyUnit.Megajoule);
+            return new Energy(megajoules, EnergyUnit.Megajoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegawattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegawattDays(QuantityValue megawattdays)
+        public static Energy FromMegawattDays(double megawattdays)
         {
-            double value = (double) megawattdays;
-            return new Energy(value, EnergyUnit.MegawattDay);
+            return new Energy(megawattdays, EnergyUnit.MegawattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegawattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegawattHours(QuantityValue megawatthours)
+        public static Energy FromMegawattHours(double megawatthours)
         {
-            double value = (double) megawatthours;
-            return new Energy(value, EnergyUnit.MegawattHour);
+            return new Energy(megawatthours, EnergyUnit.MegawattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Microjoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMicrojoules(QuantityValue microjoules)
+        public static Energy FromMicrojoules(double microjoules)
         {
-            double value = (double) microjoules;
-            return new Energy(value, EnergyUnit.Microjoule);
+            return new Energy(microjoules, EnergyUnit.Microjoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Millijoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMillijoules(QuantityValue millijoules)
+        public static Energy FromMillijoules(double millijoules)
         {
-            double value = (double) millijoules;
-            return new Energy(value, EnergyUnit.Millijoule);
+            return new Energy(millijoules, EnergyUnit.Millijoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Nanojoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromNanojoules(QuantityValue nanojoules)
+        public static Energy FromNanojoules(double nanojoules)
         {
-            double value = (double) nanojoules;
-            return new Energy(value, EnergyUnit.Nanojoule);
+            return new Energy(nanojoules, EnergyUnit.Nanojoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Petajoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromPetajoules(QuantityValue petajoules)
+        public static Energy FromPetajoules(double petajoules)
         {
-            double value = (double) petajoules;
-            return new Energy(value, EnergyUnit.Petajoule);
+            return new Energy(petajoules, EnergyUnit.Petajoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TeraelectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTeraelectronVolts(QuantityValue teraelectronvolts)
+        public static Energy FromTeraelectronVolts(double teraelectronvolts)
         {
-            double value = (double) teraelectronvolts;
-            return new Energy(value, EnergyUnit.TeraelectronVolt);
+            return new Energy(teraelectronvolts, EnergyUnit.TeraelectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Terajoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTerajoules(QuantityValue terajoules)
+        public static Energy FromTerajoules(double terajoules)
         {
-            double value = (double) terajoules;
-            return new Energy(value, EnergyUnit.Terajoule);
+            return new Energy(terajoules, EnergyUnit.Terajoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TerawattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTerawattDays(QuantityValue terawattdays)
+        public static Energy FromTerawattDays(double terawattdays)
         {
-            double value = (double) terawattdays;
-            return new Energy(value, EnergyUnit.TerawattDay);
+            return new Energy(terawattdays, EnergyUnit.TerawattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TerawattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTerawattHours(QuantityValue terawatthours)
+        public static Energy FromTerawattHours(double terawatthours)
         {
-            double value = (double) terawatthours;
-            return new Energy(value, EnergyUnit.TerawattHour);
+            return new Energy(terawatthours, EnergyUnit.TerawattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermEc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsEc(QuantityValue thermsec)
+        public static Energy FromThermsEc(double thermsec)
         {
-            double value = (double) thermsec;
-            return new Energy(value, EnergyUnit.ThermEc);
+            return new Energy(thermsec, EnergyUnit.ThermEc);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermImperial"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsImperial(QuantityValue thermsimperial)
+        public static Energy FromThermsImperial(double thermsimperial)
         {
-            double value = (double) thermsimperial;
-            return new Energy(value, EnergyUnit.ThermImperial);
+            return new Energy(thermsimperial, EnergyUnit.ThermImperial);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermUs"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsUs(QuantityValue thermsus)
+        public static Energy FromThermsUs(double thermsus)
         {
-            double value = (double) thermsus;
-            return new Energy(value, EnergyUnit.ThermUs);
+            return new Energy(thermsus, EnergyUnit.ThermUs);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.WattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromWattDays(QuantityValue wattdays)
+        public static Energy FromWattDays(double wattdays)
         {
-            double value = (double) wattdays;
-            return new Energy(value, EnergyUnit.WattDay);
+            return new Energy(wattdays, EnergyUnit.WattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.WattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromWattHours(QuantityValue watthours)
+        public static Energy FromWattHours(double watthours)
         {
-            double value = (double) watthours;
-            return new Energy(value, EnergyUnit.WattHour);
+            return new Energy(watthours, EnergyUnit.WattHour);
         }
 
         /// <summary>
@@ -950,9 +910,9 @@ public static Energy FromWattHours(QuantityValue watthours)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Energy unit value.</returns>
-        public static Energy From(QuantityValue value, EnergyUnit fromUnit)
+        public static Energy From(double value, EnergyUnit fromUnit)
         {
-            return new Energy((double)value, fromUnit);
+            return new Energy(value, fromUnit);
         }
 
         #endregion
@@ -1427,15 +1387,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is EnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is EnergyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyUnit)} is supported.", nameof(unit));
@@ -1628,18 +1579,6 @@ public Energy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<EnergyUnit> IQuantity<EnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not EnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
index c5f3640ac6..da6aa0ead8 100644
--- a/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct EnergyDensity :
-        IArithmeticQuantity<EnergyDensity, EnergyDensityUnit, double>,
+        IArithmeticQuantity<EnergyDensity, EnergyDensityUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<EnergyDensity, Volume, Energy>,
 #endif
@@ -164,7 +164,7 @@ public EnergyDensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -315,120 +315,108 @@ public static string GetAbbreviation(EnergyDensityUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.GigajoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromGigajoulesPerCubicMeter(QuantityValue gigajoulespercubicmeter)
+        public static EnergyDensity FromGigajoulesPerCubicMeter(double gigajoulespercubicmeter)
         {
-            double value = (double) gigajoulespercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.GigajoulePerCubicMeter);
+            return new EnergyDensity(gigajoulespercubicmeter, EnergyDensityUnit.GigajoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.GigawattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromGigawattHoursPerCubicMeter(QuantityValue gigawatthourspercubicmeter)
+        public static EnergyDensity FromGigawattHoursPerCubicMeter(double gigawatthourspercubicmeter)
         {
-            double value = (double) gigawatthourspercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.GigawattHourPerCubicMeter);
+            return new EnergyDensity(gigawatthourspercubicmeter, EnergyDensityUnit.GigawattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.JoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromJoulesPerCubicMeter(QuantityValue joulespercubicmeter)
+        public static EnergyDensity FromJoulesPerCubicMeter(double joulespercubicmeter)
         {
-            double value = (double) joulespercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.JoulePerCubicMeter);
+            return new EnergyDensity(joulespercubicmeter, EnergyDensityUnit.JoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.KilojoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromKilojoulesPerCubicMeter(QuantityValue kilojoulespercubicmeter)
+        public static EnergyDensity FromKilojoulesPerCubicMeter(double kilojoulespercubicmeter)
         {
-            double value = (double) kilojoulespercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.KilojoulePerCubicMeter);
+            return new EnergyDensity(kilojoulespercubicmeter, EnergyDensityUnit.KilojoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.KilowattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromKilowattHoursPerCubicMeter(QuantityValue kilowatthourspercubicmeter)
+        public static EnergyDensity FromKilowattHoursPerCubicMeter(double kilowatthourspercubicmeter)
         {
-            double value = (double) kilowatthourspercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.KilowattHourPerCubicMeter);
+            return new EnergyDensity(kilowatthourspercubicmeter, EnergyDensityUnit.KilowattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.MegajoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromMegajoulesPerCubicMeter(QuantityValue megajoulespercubicmeter)
+        public static EnergyDensity FromMegajoulesPerCubicMeter(double megajoulespercubicmeter)
         {
-            double value = (double) megajoulespercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.MegajoulePerCubicMeter);
+            return new EnergyDensity(megajoulespercubicmeter, EnergyDensityUnit.MegajoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.MegawattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromMegawattHoursPerCubicMeter(QuantityValue megawatthourspercubicmeter)
+        public static EnergyDensity FromMegawattHoursPerCubicMeter(double megawatthourspercubicmeter)
         {
-            double value = (double) megawatthourspercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.MegawattHourPerCubicMeter);
+            return new EnergyDensity(megawatthourspercubicmeter, EnergyDensityUnit.MegawattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.PetajoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromPetajoulesPerCubicMeter(QuantityValue petajoulespercubicmeter)
+        public static EnergyDensity FromPetajoulesPerCubicMeter(double petajoulespercubicmeter)
         {
-            double value = (double) petajoulespercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.PetajoulePerCubicMeter);
+            return new EnergyDensity(petajoulespercubicmeter, EnergyDensityUnit.PetajoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.PetawattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromPetawattHoursPerCubicMeter(QuantityValue petawatthourspercubicmeter)
+        public static EnergyDensity FromPetawattHoursPerCubicMeter(double petawatthourspercubicmeter)
         {
-            double value = (double) petawatthourspercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.PetawattHourPerCubicMeter);
+            return new EnergyDensity(petawatthourspercubicmeter, EnergyDensityUnit.PetawattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.TerajoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromTerajoulesPerCubicMeter(QuantityValue terajoulespercubicmeter)
+        public static EnergyDensity FromTerajoulesPerCubicMeter(double terajoulespercubicmeter)
         {
-            double value = (double) terajoulespercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.TerajoulePerCubicMeter);
+            return new EnergyDensity(terajoulespercubicmeter, EnergyDensityUnit.TerajoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.TerawattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromTerawattHoursPerCubicMeter(QuantityValue terawatthourspercubicmeter)
+        public static EnergyDensity FromTerawattHoursPerCubicMeter(double terawatthourspercubicmeter)
         {
-            double value = (double) terawatthourspercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.TerawattHourPerCubicMeter);
+            return new EnergyDensity(terawatthourspercubicmeter, EnergyDensityUnit.TerawattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.WattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromWattHoursPerCubicMeter(QuantityValue watthourspercubicmeter)
+        public static EnergyDensity FromWattHoursPerCubicMeter(double watthourspercubicmeter)
         {
-            double value = (double) watthourspercubicmeter;
-            return new EnergyDensity(value, EnergyDensityUnit.WattHourPerCubicMeter);
+            return new EnergyDensity(watthourspercubicmeter, EnergyDensityUnit.WattHourPerCubicMeter);
         }
 
         /// <summary>
@@ -437,9 +425,9 @@ public static EnergyDensity FromWattHoursPerCubicMeter(QuantityValue watthourspe
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>EnergyDensity unit value.</returns>
-        public static EnergyDensity From(QuantityValue value, EnergyDensityUnit fromUnit)
+        public static EnergyDensity From(double value, EnergyDensityUnit fromUnit)
         {
-            return new EnergyDensity((double)value, fromUnit);
+            return new EnergyDensity(value, fromUnit);
         }
 
         #endregion
@@ -860,15 +848,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is EnergyDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyDensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is EnergyDensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyDensityUnit)} is supported.", nameof(unit));
@@ -1005,18 +984,6 @@ public EnergyDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<EnergyDensityUnit> IQuantity<EnergyDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not EnergyDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EnergyDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
index ed43a2be22..53677dec17 100644
--- a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Entropy :
-        IArithmeticQuantity<Entropy, EntropyUnit, double>,
+        IArithmeticQuantity<Entropy, EntropyUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Entropy, TemperatureDelta, Energy>,
         IDivisionOperators<Entropy, Mass, SpecificEntropy>,
@@ -160,7 +160,7 @@ public Entropy(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -276,70 +276,63 @@ public static string GetAbbreviation(EntropyUnit unit, IFormatProvider? provider
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.CaloriePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromCaloriesPerKelvin(QuantityValue caloriesperkelvin)
+        public static Entropy FromCaloriesPerKelvin(double caloriesperkelvin)
         {
-            double value = (double) caloriesperkelvin;
-            return new Entropy(value, EntropyUnit.CaloriePerKelvin);
+            return new Entropy(caloriesperkelvin, EntropyUnit.CaloriePerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.JoulePerDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromJoulesPerDegreeCelsius(QuantityValue joulesperdegreecelsius)
+        public static Entropy FromJoulesPerDegreeCelsius(double joulesperdegreecelsius)
         {
-            double value = (double) joulesperdegreecelsius;
-            return new Entropy(value, EntropyUnit.JoulePerDegreeCelsius);
+            return new Entropy(joulesperdegreecelsius, EntropyUnit.JoulePerDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.JoulePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromJoulesPerKelvin(QuantityValue joulesperkelvin)
+        public static Entropy FromJoulesPerKelvin(double joulesperkelvin)
         {
-            double value = (double) joulesperkelvin;
-            return new Entropy(value, EntropyUnit.JoulePerKelvin);
+            return new Entropy(joulesperkelvin, EntropyUnit.JoulePerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilocaloriePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilocaloriesPerKelvin(QuantityValue kilocaloriesperkelvin)
+        public static Entropy FromKilocaloriesPerKelvin(double kilocaloriesperkelvin)
         {
-            double value = (double) kilocaloriesperkelvin;
-            return new Entropy(value, EntropyUnit.KilocaloriePerKelvin);
+            return new Entropy(kilocaloriesperkelvin, EntropyUnit.KilocaloriePerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilojoulePerDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilojoulesPerDegreeCelsius(QuantityValue kilojoulesperdegreecelsius)
+        public static Entropy FromKilojoulesPerDegreeCelsius(double kilojoulesperdegreecelsius)
         {
-            double value = (double) kilojoulesperdegreecelsius;
-            return new Entropy(value, EntropyUnit.KilojoulePerDegreeCelsius);
+            return new Entropy(kilojoulesperdegreecelsius, EntropyUnit.KilojoulePerDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilojoulePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilojoulesPerKelvin(QuantityValue kilojoulesperkelvin)
+        public static Entropy FromKilojoulesPerKelvin(double kilojoulesperkelvin)
         {
-            double value = (double) kilojoulesperkelvin;
-            return new Entropy(value, EntropyUnit.KilojoulePerKelvin);
+            return new Entropy(kilojoulesperkelvin, EntropyUnit.KilojoulePerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.MegajoulePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromMegajoulesPerKelvin(QuantityValue megajoulesperkelvin)
+        public static Entropy FromMegajoulesPerKelvin(double megajoulesperkelvin)
         {
-            double value = (double) megajoulesperkelvin;
-            return new Entropy(value, EntropyUnit.MegajoulePerKelvin);
+            return new Entropy(megajoulesperkelvin, EntropyUnit.MegajoulePerKelvin);
         }
 
         /// <summary>
@@ -348,9 +341,9 @@ public static Entropy FromMegajoulesPerKelvin(QuantityValue megajoulesperkelvin)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Entropy unit value.</returns>
-        public static Entropy From(QuantityValue value, EntropyUnit fromUnit)
+        public static Entropy From(double value, EntropyUnit fromUnit)
         {
-            return new Entropy((double)value, fromUnit);
+            return new Entropy(value, fromUnit);
         }
 
         #endregion
@@ -777,15 +770,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is EntropyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EntropyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is EntropyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EntropyUnit)} is supported.", nameof(unit));
@@ -912,18 +896,6 @@ public Entropy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<EntropyUnit> IQuantity<EntropyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not EntropyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(EntropyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
index c3d4390d12..8e0d17e118 100644
--- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Force :
-        IArithmeticQuantity<Force, ForceUnit, double>,
+        IArithmeticQuantity<Force, ForceUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Force, Mass, Acceleration>,
         IDivisionOperators<Force, ForceChangeRate, Duration>,
@@ -176,7 +176,7 @@ public Force(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -348,150 +348,135 @@ public static string GetAbbreviation(ForceUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Decanewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromDecanewtons(QuantityValue decanewtons)
+        public static Force FromDecanewtons(double decanewtons)
         {
-            double value = (double) decanewtons;
-            return new Force(value, ForceUnit.Decanewton);
+            return new Force(decanewtons, ForceUnit.Decanewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Dyn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromDyne(QuantityValue dyne)
+        public static Force FromDyne(double dyne)
         {
-            double value = (double) dyne;
-            return new Force(value, ForceUnit.Dyn);
+            return new Force(dyne, ForceUnit.Dyn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KilogramForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilogramsForce(QuantityValue kilogramsforce)
+        public static Force FromKilogramsForce(double kilogramsforce)
         {
-            double value = (double) kilogramsforce;
-            return new Force(value, ForceUnit.KilogramForce);
+            return new Force(kilogramsforce, ForceUnit.KilogramForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Kilonewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilonewtons(QuantityValue kilonewtons)
+        public static Force FromKilonewtons(double kilonewtons)
         {
-            double value = (double) kilonewtons;
-            return new Force(value, ForceUnit.Kilonewton);
+            return new Force(kilonewtons, ForceUnit.Kilonewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KiloPond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKiloPonds(QuantityValue kiloponds)
+        public static Force FromKiloPonds(double kiloponds)
         {
-            double value = (double) kiloponds;
-            return new Force(value, ForceUnit.KiloPond);
+            return new Force(kiloponds, ForceUnit.KiloPond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KilopoundForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilopoundsForce(QuantityValue kilopoundsforce)
+        public static Force FromKilopoundsForce(double kilopoundsforce)
         {
-            double value = (double) kilopoundsforce;
-            return new Force(value, ForceUnit.KilopoundForce);
+            return new Force(kilopoundsforce, ForceUnit.KilopoundForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Meganewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMeganewtons(QuantityValue meganewtons)
+        public static Force FromMeganewtons(double meganewtons)
         {
-            double value = (double) meganewtons;
-            return new Force(value, ForceUnit.Meganewton);
+            return new Force(meganewtons, ForceUnit.Meganewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Micronewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMicronewtons(QuantityValue micronewtons)
+        public static Force FromMicronewtons(double micronewtons)
         {
-            double value = (double) micronewtons;
-            return new Force(value, ForceUnit.Micronewton);
+            return new Force(micronewtons, ForceUnit.Micronewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Millinewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMillinewtons(QuantityValue millinewtons)
+        public static Force FromMillinewtons(double millinewtons)
         {
-            double value = (double) millinewtons;
-            return new Force(value, ForceUnit.Millinewton);
+            return new Force(millinewtons, ForceUnit.Millinewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Newton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromNewtons(QuantityValue newtons)
+        public static Force FromNewtons(double newtons)
         {
-            double value = (double) newtons;
-            return new Force(value, ForceUnit.Newton);
+            return new Force(newtons, ForceUnit.Newton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.OunceForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromOunceForce(QuantityValue ounceforce)
+        public static Force FromOunceForce(double ounceforce)
         {
-            double value = (double) ounceforce;
-            return new Force(value, ForceUnit.OunceForce);
+            return new Force(ounceforce, ForceUnit.OunceForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Poundal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromPoundals(QuantityValue poundals)
+        public static Force FromPoundals(double poundals)
         {
-            double value = (double) poundals;
-            return new Force(value, ForceUnit.Poundal);
+            return new Force(poundals, ForceUnit.Poundal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.PoundForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromPoundsForce(QuantityValue poundsforce)
+        public static Force FromPoundsForce(double poundsforce)
         {
-            double value = (double) poundsforce;
-            return new Force(value, ForceUnit.PoundForce);
+            return new Force(poundsforce, ForceUnit.PoundForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.ShortTonForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromShortTonsForce(QuantityValue shorttonsforce)
+        public static Force FromShortTonsForce(double shorttonsforce)
         {
-            double value = (double) shorttonsforce;
-            return new Force(value, ForceUnit.ShortTonForce);
+            return new Force(shorttonsforce, ForceUnit.ShortTonForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.TonneForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromTonnesForce(QuantityValue tonnesforce)
+        public static Force FromTonnesForce(double tonnesforce)
         {
-            double value = (double) tonnesforce;
-            return new Force(value, ForceUnit.TonneForce);
+            return new Force(tonnesforce, ForceUnit.TonneForce);
         }
 
         /// <summary>
@@ -500,9 +485,9 @@ public static Force FromTonnesForce(QuantityValue tonnesforce)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Force unit value.</returns>
-        public static Force From(QuantityValue value, ForceUnit fromUnit)
+        public static Force From(double value, ForceUnit fromUnit)
         {
-            return new Force((double)value, fromUnit);
+            return new Force(value, fromUnit);
         }
 
         #endregion
@@ -977,15 +962,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ForceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ForceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceUnit)} is supported.", nameof(unit));
@@ -1128,18 +1104,6 @@ public Force ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ForceUnit> IQuantity<ForceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ForceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
index 6b54cb1e24..63b0c2a3cc 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ForceChangeRate :
-        IArithmeticQuantity<ForceChangeRate, ForceChangeRateUnit, double>,
+        IArithmeticQuantity<ForceChangeRate, ForceChangeRateUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<ForceChangeRate, Duration, Force>,
         IMultiplyOperators<ForceChangeRate, TimeSpan, Force>,
@@ -168,7 +168,7 @@ public ForceChangeRate(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -340,150 +340,135 @@ public static string GetAbbreviation(ForceChangeRateUnit unit, IFormatProvider?
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.CentinewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromCentinewtonsPerSecond(QuantityValue centinewtonspersecond)
+        public static ForceChangeRate FromCentinewtonsPerSecond(double centinewtonspersecond)
         {
-            double value = (double) centinewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.CentinewtonPerSecond);
+            return new ForceChangeRate(centinewtonspersecond, ForceChangeRateUnit.CentinewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecanewtonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecanewtonsPerMinute(QuantityValue decanewtonsperminute)
+        public static ForceChangeRate FromDecanewtonsPerMinute(double decanewtonsperminute)
         {
-            double value = (double) decanewtonsperminute;
-            return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerMinute);
+            return new ForceChangeRate(decanewtonsperminute, ForceChangeRateUnit.DecanewtonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecanewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecanewtonsPerSecond(QuantityValue decanewtonspersecond)
+        public static ForceChangeRate FromDecanewtonsPerSecond(double decanewtonspersecond)
         {
-            double value = (double) decanewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerSecond);
+            return new ForceChangeRate(decanewtonspersecond, ForceChangeRateUnit.DecanewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecinewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecinewtonsPerSecond(QuantityValue decinewtonspersecond)
+        public static ForceChangeRate FromDecinewtonsPerSecond(double decinewtonspersecond)
         {
-            double value = (double) decinewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.DecinewtonPerSecond);
+            return new ForceChangeRate(decinewtonspersecond, ForceChangeRateUnit.DecinewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilonewtonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilonewtonsPerMinute(QuantityValue kilonewtonsperminute)
+        public static ForceChangeRate FromKilonewtonsPerMinute(double kilonewtonsperminute)
         {
-            double value = (double) kilonewtonsperminute;
-            return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerMinute);
+            return new ForceChangeRate(kilonewtonsperminute, ForceChangeRateUnit.KilonewtonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilonewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilonewtonsPerSecond(QuantityValue kilonewtonspersecond)
+        public static ForceChangeRate FromKilonewtonsPerSecond(double kilonewtonspersecond)
         {
-            double value = (double) kilonewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond);
+            return new ForceChangeRate(kilonewtonspersecond, ForceChangeRateUnit.KilonewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilopoundForcePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilopoundsForcePerMinute(QuantityValue kilopoundsforceperminute)
+        public static ForceChangeRate FromKilopoundsForcePerMinute(double kilopoundsforceperminute)
         {
-            double value = (double) kilopoundsforceperminute;
-            return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute);
+            return new ForceChangeRate(kilopoundsforceperminute, ForceChangeRateUnit.KilopoundForcePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilopoundForcePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilopoundsForcePerSecond(QuantityValue kilopoundsforcepersecond)
+        public static ForceChangeRate FromKilopoundsForcePerSecond(double kilopoundsforcepersecond)
         {
-            double value = (double) kilopoundsforcepersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond);
+            return new ForceChangeRate(kilopoundsforcepersecond, ForceChangeRateUnit.KilopoundForcePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.MicronewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromMicronewtonsPerSecond(QuantityValue micronewtonspersecond)
+        public static ForceChangeRate FromMicronewtonsPerSecond(double micronewtonspersecond)
         {
-            double value = (double) micronewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.MicronewtonPerSecond);
+            return new ForceChangeRate(micronewtonspersecond, ForceChangeRateUnit.MicronewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.MillinewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromMillinewtonsPerSecond(QuantityValue millinewtonspersecond)
+        public static ForceChangeRate FromMillinewtonsPerSecond(double millinewtonspersecond)
         {
-            double value = (double) millinewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.MillinewtonPerSecond);
+            return new ForceChangeRate(millinewtonspersecond, ForceChangeRateUnit.MillinewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NanonewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNanonewtonsPerSecond(QuantityValue nanonewtonspersecond)
+        public static ForceChangeRate FromNanonewtonsPerSecond(double nanonewtonspersecond)
         {
-            double value = (double) nanonewtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.NanonewtonPerSecond);
+            return new ForceChangeRate(nanonewtonspersecond, ForceChangeRateUnit.NanonewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NewtonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNewtonsPerMinute(QuantityValue newtonsperminute)
+        public static ForceChangeRate FromNewtonsPerMinute(double newtonsperminute)
         {
-            double value = (double) newtonsperminute;
-            return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerMinute);
+            return new ForceChangeRate(newtonsperminute, ForceChangeRateUnit.NewtonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNewtonsPerSecond(QuantityValue newtonspersecond)
+        public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond)
         {
-            double value = (double) newtonspersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond);
+            return new ForceChangeRate(newtonspersecond, ForceChangeRateUnit.NewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.PoundForcePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromPoundsForcePerMinute(QuantityValue poundsforceperminute)
+        public static ForceChangeRate FromPoundsForcePerMinute(double poundsforceperminute)
         {
-            double value = (double) poundsforceperminute;
-            return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute);
+            return new ForceChangeRate(poundsforceperminute, ForceChangeRateUnit.PoundForcePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.PoundForcePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromPoundsForcePerSecond(QuantityValue poundsforcepersecond)
+        public static ForceChangeRate FromPoundsForcePerSecond(double poundsforcepersecond)
         {
-            double value = (double) poundsforcepersecond;
-            return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond);
+            return new ForceChangeRate(poundsforcepersecond, ForceChangeRateUnit.PoundForcePerSecond);
         }
 
         /// <summary>
@@ -492,9 +477,9 @@ public static ForceChangeRate FromPoundsForcePerSecond(QuantityValue poundsforce
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ForceChangeRate unit value.</returns>
-        public static ForceChangeRate From(QuantityValue value, ForceChangeRateUnit fromUnit)
+        public static ForceChangeRate From(double value, ForceChangeRateUnit fromUnit)
         {
-            return new ForceChangeRate((double)value, fromUnit);
+            return new ForceChangeRate(value, fromUnit);
         }
 
         #endregion
@@ -927,15 +912,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ForceChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceChangeRateUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ForceChangeRateUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceChangeRateUnit)} is supported.", nameof(unit));
@@ -1078,18 +1054,6 @@ public ForceChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ForceChangeRateUnit> IQuantity<ForceChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ForceChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForceChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
index c4ba2a2396..ccb2a8f698 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ForcePerLength :
-        IArithmeticQuantity<ForcePerLength, ForcePerLengthUnit, double>,
+        IArithmeticQuantity<ForcePerLength, ForcePerLengthUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<ForcePerLength, Length, Force>,
         IDivisionOperators<ForcePerLength, ReciprocalLength, Force>,
@@ -194,7 +194,7 @@ public ForcePerLength(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -527,380 +527,342 @@ public static string GetAbbreviation(ForcePerLengthUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerCentimeter(QuantityValue centinewtonspercentimeter)
+        public static ForcePerLength FromCentinewtonsPerCentimeter(double centinewtonspercentimeter)
         {
-            double value = (double) centinewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter);
+            return new ForcePerLength(centinewtonspercentimeter, ForcePerLengthUnit.CentinewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerMeter(QuantityValue centinewtonspermeter)
+        public static ForcePerLength FromCentinewtonsPerMeter(double centinewtonspermeter)
         {
-            double value = (double) centinewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter);
+            return new ForcePerLength(centinewtonspermeter, ForcePerLengthUnit.CentinewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerMillimeter(QuantityValue centinewtonspermillimeter)
+        public static ForcePerLength FromCentinewtonsPerMillimeter(double centinewtonspermillimeter)
         {
-            double value = (double) centinewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter);
+            return new ForcePerLength(centinewtonspermillimeter, ForcePerLengthUnit.CentinewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerCentimeter(QuantityValue decanewtonspercentimeter)
+        public static ForcePerLength FromDecanewtonsPerCentimeter(double decanewtonspercentimeter)
         {
-            double value = (double) decanewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter);
+            return new ForcePerLength(decanewtonspercentimeter, ForcePerLengthUnit.DecanewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerMeter(QuantityValue decanewtonspermeter)
+        public static ForcePerLength FromDecanewtonsPerMeter(double decanewtonspermeter)
         {
-            double value = (double) decanewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter);
+            return new ForcePerLength(decanewtonspermeter, ForcePerLengthUnit.DecanewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerMillimeter(QuantityValue decanewtonspermillimeter)
+        public static ForcePerLength FromDecanewtonsPerMillimeter(double decanewtonspermillimeter)
         {
-            double value = (double) decanewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter);
+            return new ForcePerLength(decanewtonspermillimeter, ForcePerLengthUnit.DecanewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerCentimeter(QuantityValue decinewtonspercentimeter)
+        public static ForcePerLength FromDecinewtonsPerCentimeter(double decinewtonspercentimeter)
         {
-            double value = (double) decinewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter);
+            return new ForcePerLength(decinewtonspercentimeter, ForcePerLengthUnit.DecinewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerMeter(QuantityValue decinewtonspermeter)
+        public static ForcePerLength FromDecinewtonsPerMeter(double decinewtonspermeter)
         {
-            double value = (double) decinewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter);
+            return new ForcePerLength(decinewtonspermeter, ForcePerLengthUnit.DecinewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerMillimeter(QuantityValue decinewtonspermillimeter)
+        public static ForcePerLength FromDecinewtonsPerMillimeter(double decinewtonspermillimeter)
         {
-            double value = (double) decinewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter);
+            return new ForcePerLength(decinewtonspermillimeter, ForcePerLengthUnit.DecinewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerCentimeter(QuantityValue kilogramsforcepercentimeter)
+        public static ForcePerLength FromKilogramsForcePerCentimeter(double kilogramsforcepercentimeter)
         {
-            double value = (double) kilogramsforcepercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter);
+            return new ForcePerLength(kilogramsforcepercentimeter, ForcePerLengthUnit.KilogramForcePerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerMeter(QuantityValue kilogramsforcepermeter)
+        public static ForcePerLength FromKilogramsForcePerMeter(double kilogramsforcepermeter)
         {
-            double value = (double) kilogramsforcepermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter);
+            return new ForcePerLength(kilogramsforcepermeter, ForcePerLengthUnit.KilogramForcePerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerMillimeter(QuantityValue kilogramsforcepermillimeter)
+        public static ForcePerLength FromKilogramsForcePerMillimeter(double kilogramsforcepermillimeter)
         {
-            double value = (double) kilogramsforcepermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter);
+            return new ForcePerLength(kilogramsforcepermillimeter, ForcePerLengthUnit.KilogramForcePerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerCentimeter(QuantityValue kilonewtonspercentimeter)
+        public static ForcePerLength FromKilonewtonsPerCentimeter(double kilonewtonspercentimeter)
         {
-            double value = (double) kilonewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter);
+            return new ForcePerLength(kilonewtonspercentimeter, ForcePerLengthUnit.KilonewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerMeter(QuantityValue kilonewtonspermeter)
+        public static ForcePerLength FromKilonewtonsPerMeter(double kilonewtonspermeter)
         {
-            double value = (double) kilonewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter);
+            return new ForcePerLength(kilonewtonspermeter, ForcePerLengthUnit.KilonewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerMillimeter(QuantityValue kilonewtonspermillimeter)
+        public static ForcePerLength FromKilonewtonsPerMillimeter(double kilonewtonspermillimeter)
         {
-            double value = (double) kilonewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter);
+            return new ForcePerLength(kilonewtonspermillimeter, ForcePerLengthUnit.KilonewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilopoundForcePerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilopoundsForcePerFoot(QuantityValue kilopoundsforceperfoot)
+        public static ForcePerLength FromKilopoundsForcePerFoot(double kilopoundsforceperfoot)
         {
-            double value = (double) kilopoundsforceperfoot;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot);
+            return new ForcePerLength(kilopoundsforceperfoot, ForcePerLengthUnit.KilopoundForcePerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilopoundForcePerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilopoundsForcePerInch(QuantityValue kilopoundsforceperinch)
+        public static ForcePerLength FromKilopoundsForcePerInch(double kilopoundsforceperinch)
         {
-            double value = (double) kilopoundsforceperinch;
-            return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch);
+            return new ForcePerLength(kilopoundsforceperinch, ForcePerLengthUnit.KilopoundForcePerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerCentimeter(QuantityValue meganewtonspercentimeter)
+        public static ForcePerLength FromMeganewtonsPerCentimeter(double meganewtonspercentimeter)
         {
-            double value = (double) meganewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter);
+            return new ForcePerLength(meganewtonspercentimeter, ForcePerLengthUnit.MeganewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerMeter(QuantityValue meganewtonspermeter)
+        public static ForcePerLength FromMeganewtonsPerMeter(double meganewtonspermeter)
         {
-            double value = (double) meganewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter);
+            return new ForcePerLength(meganewtonspermeter, ForcePerLengthUnit.MeganewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerMillimeter(QuantityValue meganewtonspermillimeter)
+        public static ForcePerLength FromMeganewtonsPerMillimeter(double meganewtonspermillimeter)
         {
-            double value = (double) meganewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter);
+            return new ForcePerLength(meganewtonspermillimeter, ForcePerLengthUnit.MeganewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerCentimeter(QuantityValue micronewtonspercentimeter)
+        public static ForcePerLength FromMicronewtonsPerCentimeter(double micronewtonspercentimeter)
         {
-            double value = (double) micronewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter);
+            return new ForcePerLength(micronewtonspercentimeter, ForcePerLengthUnit.MicronewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerMeter(QuantityValue micronewtonspermeter)
+        public static ForcePerLength FromMicronewtonsPerMeter(double micronewtonspermeter)
         {
-            double value = (double) micronewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter);
+            return new ForcePerLength(micronewtonspermeter, ForcePerLengthUnit.MicronewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerMillimeter(QuantityValue micronewtonspermillimeter)
+        public static ForcePerLength FromMicronewtonsPerMillimeter(double micronewtonspermillimeter)
         {
-            double value = (double) micronewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter);
+            return new ForcePerLength(micronewtonspermillimeter, ForcePerLengthUnit.MicronewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerCentimeter(QuantityValue millinewtonspercentimeter)
+        public static ForcePerLength FromMillinewtonsPerCentimeter(double millinewtonspercentimeter)
         {
-            double value = (double) millinewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter);
+            return new ForcePerLength(millinewtonspercentimeter, ForcePerLengthUnit.MillinewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerMeter(QuantityValue millinewtonspermeter)
+        public static ForcePerLength FromMillinewtonsPerMeter(double millinewtonspermeter)
         {
-            double value = (double) millinewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter);
+            return new ForcePerLength(millinewtonspermeter, ForcePerLengthUnit.MillinewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerMillimeter(QuantityValue millinewtonspermillimeter)
+        public static ForcePerLength FromMillinewtonsPerMillimeter(double millinewtonspermillimeter)
         {
-            double value = (double) millinewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter);
+            return new ForcePerLength(millinewtonspermillimeter, ForcePerLengthUnit.MillinewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerCentimeter(QuantityValue nanonewtonspercentimeter)
+        public static ForcePerLength FromNanonewtonsPerCentimeter(double nanonewtonspercentimeter)
         {
-            double value = (double) nanonewtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter);
+            return new ForcePerLength(nanonewtonspercentimeter, ForcePerLengthUnit.NanonewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerMeter(QuantityValue nanonewtonspermeter)
+        public static ForcePerLength FromNanonewtonsPerMeter(double nanonewtonspermeter)
         {
-            double value = (double) nanonewtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter);
+            return new ForcePerLength(nanonewtonspermeter, ForcePerLengthUnit.NanonewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerMillimeter(QuantityValue nanonewtonspermillimeter)
+        public static ForcePerLength FromNanonewtonsPerMillimeter(double nanonewtonspermillimeter)
         {
-            double value = (double) nanonewtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter);
+            return new ForcePerLength(nanonewtonspermillimeter, ForcePerLengthUnit.NanonewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerCentimeter(QuantityValue newtonspercentimeter)
+        public static ForcePerLength FromNewtonsPerCentimeter(double newtonspercentimeter)
         {
-            double value = (double) newtonspercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter);
+            return new ForcePerLength(newtonspercentimeter, ForcePerLengthUnit.NewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerMeter(QuantityValue newtonspermeter)
+        public static ForcePerLength FromNewtonsPerMeter(double newtonspermeter)
         {
-            double value = (double) newtonspermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter);
+            return new ForcePerLength(newtonspermeter, ForcePerLengthUnit.NewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerMillimeter(QuantityValue newtonspermillimeter)
+        public static ForcePerLength FromNewtonsPerMillimeter(double newtonspermillimeter)
         {
-            double value = (double) newtonspermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter);
+            return new ForcePerLength(newtonspermillimeter, ForcePerLengthUnit.NewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerFoot(QuantityValue poundsforceperfoot)
+        public static ForcePerLength FromPoundsForcePerFoot(double poundsforceperfoot)
         {
-            double value = (double) poundsforceperfoot;
-            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot);
+            return new ForcePerLength(poundsforceperfoot, ForcePerLengthUnit.PoundForcePerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerInch(QuantityValue poundsforceperinch)
+        public static ForcePerLength FromPoundsForcePerInch(double poundsforceperinch)
         {
-            double value = (double) poundsforceperinch;
-            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch);
+            return new ForcePerLength(poundsforceperinch, ForcePerLengthUnit.PoundForcePerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerYard(QuantityValue poundsforceperyard)
+        public static ForcePerLength FromPoundsForcePerYard(double poundsforceperyard)
         {
-            double value = (double) poundsforceperyard;
-            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard);
+            return new ForcePerLength(poundsforceperyard, ForcePerLengthUnit.PoundForcePerYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerCentimeter(QuantityValue tonnesforcepercentimeter)
+        public static ForcePerLength FromTonnesForcePerCentimeter(double tonnesforcepercentimeter)
         {
-            double value = (double) tonnesforcepercentimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter);
+            return new ForcePerLength(tonnesforcepercentimeter, ForcePerLengthUnit.TonneForcePerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerMeter(QuantityValue tonnesforcepermeter)
+        public static ForcePerLength FromTonnesForcePerMeter(double tonnesforcepermeter)
         {
-            double value = (double) tonnesforcepermeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter);
+            return new ForcePerLength(tonnesforcepermeter, ForcePerLengthUnit.TonneForcePerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerMillimeter(QuantityValue tonnesforcepermillimeter)
+        public static ForcePerLength FromTonnesForcePerMillimeter(double tonnesforcepermillimeter)
         {
-            double value = (double) tonnesforcepermillimeter;
-            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter);
+            return new ForcePerLength(tonnesforcepermillimeter, ForcePerLengthUnit.TonneForcePerMillimeter);
         }
 
         /// <summary>
@@ -909,9 +871,9 @@ public static ForcePerLength FromTonnesForcePerMillimeter(QuantityValue tonnesfo
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ForcePerLength unit value.</returns>
-        public static ForcePerLength From(QuantityValue value, ForcePerLengthUnit fromUnit)
+        public static ForcePerLength From(double value, ForcePerLengthUnit fromUnit)
         {
-            return new ForcePerLength((double)value, fromUnit);
+            return new ForcePerLength(value, fromUnit);
         }
 
         #endregion
@@ -1356,15 +1318,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ForcePerLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForcePerLengthUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ForcePerLengthUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForcePerLengthUnit)} is supported.", nameof(unit));
@@ -1553,18 +1506,6 @@ public ForcePerLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ForcePerLengthUnit> IQuantity<ForcePerLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ForcePerLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ForcePerLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
index c47f8d33d8..49aa24a00a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Frequency :
-        IArithmeticQuantity<Frequency, FrequencyUnit, double>,
+        IArithmeticQuantity<Frequency, FrequencyUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Frequency, Energy, Power>,
 #endif
@@ -165,7 +165,7 @@ public Frequency(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -323,130 +323,117 @@ public static string GetAbbreviation(FrequencyUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.BeatPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromBeatsPerMinute(QuantityValue beatsperminute)
+        public static Frequency FromBeatsPerMinute(double beatsperminute)
         {
-            double value = (double) beatsperminute;
-            return new Frequency(value, FrequencyUnit.BeatPerMinute);
+            return new Frequency(beatsperminute, FrequencyUnit.BeatPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.BUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromBUnits(QuantityValue bunits)
+        public static Frequency FromBUnits(double bunits)
         {
-            double value = (double) bunits;
-            return new Frequency(value, FrequencyUnit.BUnit);
+            return new Frequency(bunits, FrequencyUnit.BUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.CyclePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromCyclesPerHour(QuantityValue cyclesperhour)
+        public static Frequency FromCyclesPerHour(double cyclesperhour)
         {
-            double value = (double) cyclesperhour;
-            return new Frequency(value, FrequencyUnit.CyclePerHour);
+            return new Frequency(cyclesperhour, FrequencyUnit.CyclePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.CyclePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromCyclesPerMinute(QuantityValue cyclesperminute)
+        public static Frequency FromCyclesPerMinute(double cyclesperminute)
         {
-            double value = (double) cyclesperminute;
-            return new Frequency(value, FrequencyUnit.CyclePerMinute);
+            return new Frequency(cyclesperminute, FrequencyUnit.CyclePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Gigahertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromGigahertz(QuantityValue gigahertz)
+        public static Frequency FromGigahertz(double gigahertz)
         {
-            double value = (double) gigahertz;
-            return new Frequency(value, FrequencyUnit.Gigahertz);
+            return new Frequency(gigahertz, FrequencyUnit.Gigahertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Hertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromHertz(QuantityValue hertz)
+        public static Frequency FromHertz(double hertz)
         {
-            double value = (double) hertz;
-            return new Frequency(value, FrequencyUnit.Hertz);
+            return new Frequency(hertz, FrequencyUnit.Hertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Kilohertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromKilohertz(QuantityValue kilohertz)
+        public static Frequency FromKilohertz(double kilohertz)
         {
-            double value = (double) kilohertz;
-            return new Frequency(value, FrequencyUnit.Kilohertz);
+            return new Frequency(kilohertz, FrequencyUnit.Kilohertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Megahertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromMegahertz(QuantityValue megahertz)
+        public static Frequency FromMegahertz(double megahertz)
         {
-            double value = (double) megahertz;
-            return new Frequency(value, FrequencyUnit.Megahertz);
+            return new Frequency(megahertz, FrequencyUnit.Megahertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Microhertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromMicrohertz(QuantityValue microhertz)
+        public static Frequency FromMicrohertz(double microhertz)
         {
-            double value = (double) microhertz;
-            return new Frequency(value, FrequencyUnit.Microhertz);
+            return new Frequency(microhertz, FrequencyUnit.Microhertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Millihertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromMillihertz(QuantityValue millihertz)
+        public static Frequency FromMillihertz(double millihertz)
         {
-            double value = (double) millihertz;
-            return new Frequency(value, FrequencyUnit.Millihertz);
+            return new Frequency(millihertz, FrequencyUnit.Millihertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.PerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromPerSecond(QuantityValue persecond)
+        public static Frequency FromPerSecond(double persecond)
         {
-            double value = (double) persecond;
-            return new Frequency(value, FrequencyUnit.PerSecond);
+            return new Frequency(persecond, FrequencyUnit.PerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.RadianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromRadiansPerSecond(QuantityValue radianspersecond)
+        public static Frequency FromRadiansPerSecond(double radianspersecond)
         {
-            double value = (double) radianspersecond;
-            return new Frequency(value, FrequencyUnit.RadianPerSecond);
+            return new Frequency(radianspersecond, FrequencyUnit.RadianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Terahertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromTerahertz(QuantityValue terahertz)
+        public static Frequency FromTerahertz(double terahertz)
         {
-            double value = (double) terahertz;
-            return new Frequency(value, FrequencyUnit.Terahertz);
+            return new Frequency(terahertz, FrequencyUnit.Terahertz);
         }
 
         /// <summary>
@@ -455,9 +442,9 @@ public static Frequency FromTerahertz(QuantityValue terahertz)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Frequency unit value.</returns>
-        public static Frequency From(QuantityValue value, FrequencyUnit fromUnit)
+        public static Frequency From(double value, FrequencyUnit fromUnit)
         {
-            return new Frequency((double)value, fromUnit);
+            return new Frequency(value, fromUnit);
         }
 
         #endregion
@@ -878,15 +865,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is FrequencyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FrequencyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is FrequencyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FrequencyUnit)} is supported.", nameof(unit));
@@ -1025,18 +1003,6 @@ public Frequency ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<FrequencyUnit> IQuantity<FrequencyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not FrequencyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FrequencyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
index 58ea11bbd4..cd57722a34 100644
--- a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct FuelEfficiency :
-        IArithmeticQuantity<FuelEfficiency, FuelEfficiencyUnit, double>,
+        IArithmeticQuantity<FuelEfficiency, FuelEfficiencyUnit>,
         IComparable,
         IComparable<FuelEfficiency>,
         IConvertible,
@@ -153,7 +153,7 @@ public FuelEfficiency(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -248,40 +248,36 @@ public static string GetAbbreviation(FuelEfficiencyUnit unit, IFormatProvider? p
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.KilometerPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromKilometersPerLiter(QuantityValue kilometersperliter)
+        public static FuelEfficiency FromKilometersPerLiter(double kilometersperliter)
         {
-            double value = (double) kilometersperliter;
-            return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter);
+            return new FuelEfficiency(kilometersperliter, FuelEfficiencyUnit.KilometerPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.LiterPer100Kilometers"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromLitersPer100Kilometers(QuantityValue litersper100kilometers)
+        public static FuelEfficiency FromLitersPer100Kilometers(double litersper100kilometers)
         {
-            double value = (double) litersper100kilometers;
-            return new FuelEfficiency(value, FuelEfficiencyUnit.LiterPer100Kilometers);
+            return new FuelEfficiency(litersper100kilometers, FuelEfficiencyUnit.LiterPer100Kilometers);
         }
 
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.MilePerUkGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromMilesPerUkGallon(QuantityValue milesperukgallon)
+        public static FuelEfficiency FromMilesPerUkGallon(double milesperukgallon)
         {
-            double value = (double) milesperukgallon;
-            return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUkGallon);
+            return new FuelEfficiency(milesperukgallon, FuelEfficiencyUnit.MilePerUkGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.MilePerUsGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromMilesPerUsGallon(QuantityValue milesperusgallon)
+        public static FuelEfficiency FromMilesPerUsGallon(double milesperusgallon)
         {
-            double value = (double) milesperusgallon;
-            return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUsGallon);
+            return new FuelEfficiency(milesperusgallon, FuelEfficiencyUnit.MilePerUsGallon);
         }
 
         /// <summary>
@@ -290,9 +286,9 @@ public static FuelEfficiency FromMilesPerUsGallon(QuantityValue milesperusgallon
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>FuelEfficiency unit value.</returns>
-        public static FuelEfficiency From(QuantityValue value, FuelEfficiencyUnit fromUnit)
+        public static FuelEfficiency From(double value, FuelEfficiencyUnit fromUnit)
         {
-            return new FuelEfficiency((double)value, fromUnit);
+            return new FuelEfficiency(value, fromUnit);
         }
 
         #endregion
@@ -703,15 +699,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is FuelEfficiencyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FuelEfficiencyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is FuelEfficiencyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FuelEfficiencyUnit)} is supported.", nameof(unit));
@@ -832,18 +819,6 @@ public FuelEfficiency ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<FuelEfficiencyUnit> IQuantity<FuelEfficiencyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not FuelEfficiencyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(FuelEfficiencyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
index ef3d60e6df..577af9701d 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct HeatFlux :
-        IArithmeticQuantity<HeatFlux, HeatFluxUnit, double>,
+        IArithmeticQuantity<HeatFlux, HeatFluxUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<HeatFlux, Area, Power>,
 #endif
@@ -170,7 +170,7 @@ public HeatFlux(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -363,180 +363,162 @@ public static string GetAbbreviation(HeatFluxUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerHourSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerHourSquareFoot(QuantityValue btusperhoursquarefoot)
+        public static HeatFlux FromBtusPerHourSquareFoot(double btusperhoursquarefoot)
         {
-            double value = (double) btusperhoursquarefoot;
-            return new HeatFlux(value, HeatFluxUnit.BtuPerHourSquareFoot);
+            return new HeatFlux(btusperhoursquarefoot, HeatFluxUnit.BtuPerHourSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerMinuteSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerMinuteSquareFoot(QuantityValue btusperminutesquarefoot)
+        public static HeatFlux FromBtusPerMinuteSquareFoot(double btusperminutesquarefoot)
         {
-            double value = (double) btusperminutesquarefoot;
-            return new HeatFlux(value, HeatFluxUnit.BtuPerMinuteSquareFoot);
+            return new HeatFlux(btusperminutesquarefoot, HeatFluxUnit.BtuPerMinuteSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerSecondSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerSecondSquareFoot(QuantityValue btuspersecondsquarefoot)
+        public static HeatFlux FromBtusPerSecondSquareFoot(double btuspersecondsquarefoot)
         {
-            double value = (double) btuspersecondsquarefoot;
-            return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareFoot);
+            return new HeatFlux(btuspersecondsquarefoot, HeatFluxUnit.BtuPerSecondSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerSecondSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerSecondSquareInch(QuantityValue btuspersecondsquareinch)
+        public static HeatFlux FromBtusPerSecondSquareInch(double btuspersecondsquareinch)
         {
-            double value = (double) btuspersecondsquareinch;
-            return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareInch);
+            return new HeatFlux(btuspersecondsquareinch, HeatFluxUnit.BtuPerSecondSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CaloriePerSecondSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromCaloriesPerSecondSquareCentimeter(QuantityValue caloriespersecondsquarecentimeter)
+        public static HeatFlux FromCaloriesPerSecondSquareCentimeter(double caloriespersecondsquarecentimeter)
         {
-            double value = (double) caloriespersecondsquarecentimeter;
-            return new HeatFlux(value, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
+            return new HeatFlux(caloriespersecondsquarecentimeter, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CentiwattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromCentiwattsPerSquareMeter(QuantityValue centiwattspersquaremeter)
+        public static HeatFlux FromCentiwattsPerSquareMeter(double centiwattspersquaremeter)
         {
-            double value = (double) centiwattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMeter);
+            return new HeatFlux(centiwattspersquaremeter, HeatFluxUnit.CentiwattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.DeciwattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromDeciwattsPerSquareMeter(QuantityValue deciwattspersquaremeter)
+        public static HeatFlux FromDeciwattsPerSquareMeter(double deciwattspersquaremeter)
         {
-            double value = (double) deciwattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMeter);
+            return new HeatFlux(deciwattspersquaremeter, HeatFluxUnit.DeciwattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilocaloriePerHourSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilocaloriesPerHourSquareMeter(QuantityValue kilocaloriesperhoursquaremeter)
+        public static HeatFlux FromKilocaloriesPerHourSquareMeter(double kilocaloriesperhoursquaremeter)
         {
-            double value = (double) kilocaloriesperhoursquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.KilocaloriePerHourSquareMeter);
+            return new HeatFlux(kilocaloriesperhoursquaremeter, HeatFluxUnit.KilocaloriePerHourSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilocaloriePerSecondSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(QuantityValue kilocaloriespersecondsquarecentimeter)
+        public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(double kilocaloriespersecondsquarecentimeter)
         {
-            double value = (double) kilocaloriespersecondsquarecentimeter;
-            return new HeatFlux(value, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
+            return new HeatFlux(kilocaloriespersecondsquarecentimeter, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilowattsPerSquareMeter(QuantityValue kilowattspersquaremeter)
+        public static HeatFlux FromKilowattsPerSquareMeter(double kilowattspersquaremeter)
         {
-            double value = (double) kilowattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMeter);
+            return new HeatFlux(kilowattspersquaremeter, HeatFluxUnit.KilowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MicrowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromMicrowattsPerSquareMeter(QuantityValue microwattspersquaremeter)
+        public static HeatFlux FromMicrowattsPerSquareMeter(double microwattspersquaremeter)
         {
-            double value = (double) microwattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMeter);
+            return new HeatFlux(microwattspersquaremeter, HeatFluxUnit.MicrowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MilliwattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromMilliwattsPerSquareMeter(QuantityValue milliwattspersquaremeter)
+        public static HeatFlux FromMilliwattsPerSquareMeter(double milliwattspersquaremeter)
         {
-            double value = (double) milliwattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMeter);
+            return new HeatFlux(milliwattspersquaremeter, HeatFluxUnit.MilliwattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.NanowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromNanowattsPerSquareMeter(QuantityValue nanowattspersquaremeter)
+        public static HeatFlux FromNanowattsPerSquareMeter(double nanowattspersquaremeter)
         {
-            double value = (double) nanowattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMeter);
+            return new HeatFlux(nanowattspersquaremeter, HeatFluxUnit.NanowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.PoundForcePerFootSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromPoundsForcePerFootSecond(QuantityValue poundsforceperfootsecond)
+        public static HeatFlux FromPoundsForcePerFootSecond(double poundsforceperfootsecond)
         {
-            double value = (double) poundsforceperfootsecond;
-            return new HeatFlux(value, HeatFluxUnit.PoundForcePerFootSecond);
+            return new HeatFlux(poundsforceperfootsecond, HeatFluxUnit.PoundForcePerFootSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.PoundPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromPoundsPerSecondCubed(QuantityValue poundspersecondcubed)
+        public static HeatFlux FromPoundsPerSecondCubed(double poundspersecondcubed)
         {
-            double value = (double) poundspersecondcubed;
-            return new HeatFlux(value, HeatFluxUnit.PoundPerSecondCubed);
+            return new HeatFlux(poundspersecondcubed, HeatFluxUnit.PoundPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareFoot(QuantityValue wattspersquarefoot)
+        public static HeatFlux FromWattsPerSquareFoot(double wattspersquarefoot)
         {
-            double value = (double) wattspersquarefoot;
-            return new HeatFlux(value, HeatFluxUnit.WattPerSquareFoot);
+            return new HeatFlux(wattspersquarefoot, HeatFluxUnit.WattPerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareInch(QuantityValue wattspersquareinch)
+        public static HeatFlux FromWattsPerSquareInch(double wattspersquareinch)
         {
-            double value = (double) wattspersquareinch;
-            return new HeatFlux(value, HeatFluxUnit.WattPerSquareInch);
+            return new HeatFlux(wattspersquareinch, HeatFluxUnit.WattPerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareMeter(QuantityValue wattspersquaremeter)
+        public static HeatFlux FromWattsPerSquareMeter(double wattspersquaremeter)
         {
-            double value = (double) wattspersquaremeter;
-            return new HeatFlux(value, HeatFluxUnit.WattPerSquareMeter);
+            return new HeatFlux(wattspersquaremeter, HeatFluxUnit.WattPerSquareMeter);
         }
 
         /// <summary>
@@ -545,9 +527,9 @@ public static HeatFlux FromWattsPerSquareMeter(QuantityValue wattspersquaremeter
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>HeatFlux unit value.</returns>
-        public static HeatFlux From(QuantityValue value, HeatFluxUnit fromUnit)
+        public static HeatFlux From(double value, HeatFluxUnit fromUnit)
         {
-            return new HeatFlux((double)value, fromUnit);
+            return new HeatFlux(value, fromUnit);
         }
 
         #endregion
@@ -968,15 +950,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is HeatFluxUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatFluxUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is HeatFluxUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatFluxUnit)} is supported.", nameof(unit));
@@ -1125,18 +1098,6 @@ public HeatFlux ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<HeatFluxUnit> IQuantity<HeatFluxUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not HeatFluxUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatFluxUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
index 6372f3d2b5..1c8b3d95f0 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct HeatTransferCoefficient :
-        IArithmeticQuantity<HeatTransferCoefficient, HeatTransferCoefficientUnit, double>,
+        IArithmeticQuantity<HeatTransferCoefficient, HeatTransferCoefficientUnit>,
         IComparable,
         IComparable<HeatTransferCoefficient>,
         IConvertible,
@@ -152,7 +152,7 @@ public HeatTransferCoefficient(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -262,10 +262,9 @@ public static string GetAbbreviation(HeatTransferCoefficientUnit unit, IFormatPr
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(QuantityValue btusperhoursquarefootdegreefahrenheit)
+        public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(double btusperhoursquarefootdegreefahrenheit)
         {
-            double value = (double) btusperhoursquarefootdegreefahrenheit;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
+            return new HeatTransferCoefficient(btusperhoursquarefootdegreefahrenheit, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
         }
 
         /// <summary>
@@ -273,50 +272,45 @@ public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         [Obsolete("The name of this definition incorrectly omitted time as divisor, please use BtuPerHourSquareFootDegreeFahrenheit instead")]
-        public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(QuantityValue btuspersquarefootdegreefahrenheit)
+        public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(double btuspersquarefootdegreefahrenheit)
         {
-            double value = (double) btuspersquarefootdegreefahrenheit;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
+            return new HeatTransferCoefficient(btuspersquarefootdegreefahrenheit, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromCaloriesPerHourSquareMeterDegreeCelsius(QuantityValue caloriesperhoursquaremeterdegreecelsius)
+        public static HeatTransferCoefficient FromCaloriesPerHourSquareMeterDegreeCelsius(double caloriesperhoursquaremeterdegreecelsius)
         {
-            double value = (double) caloriesperhoursquaremeterdegreecelsius;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
+            return new HeatTransferCoefficient(caloriesperhoursquaremeterdegreecelsius, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromKilocaloriesPerHourSquareMeterDegreeCelsius(QuantityValue kilocaloriesperhoursquaremeterdegreecelsius)
+        public static HeatTransferCoefficient FromKilocaloriesPerHourSquareMeterDegreeCelsius(double kilocaloriesperhoursquaremeterdegreecelsius)
         {
-            double value = (double) kilocaloriesperhoursquaremeterdegreecelsius;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
+            return new HeatTransferCoefficient(kilocaloriesperhoursquaremeterdegreecelsius, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(QuantityValue wattspersquaremetercelsius)
+        public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(double wattspersquaremetercelsius)
         {
-            double value = (double) wattspersquaremetercelsius;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
+            return new HeatTransferCoefficient(wattspersquaremetercelsius, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(QuantityValue wattspersquaremeterkelvin)
+        public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(double wattspersquaremeterkelvin)
         {
-            double value = (double) wattspersquaremeterkelvin;
-            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
+            return new HeatTransferCoefficient(wattspersquaremeterkelvin, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
         }
 
         /// <summary>
@@ -325,9 +319,9 @@ public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(QuantityValu
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>HeatTransferCoefficient unit value.</returns>
-        public static HeatTransferCoefficient From(QuantityValue value, HeatTransferCoefficientUnit fromUnit)
+        public static HeatTransferCoefficient From(double value, HeatTransferCoefficientUnit fromUnit)
         {
-            return new HeatTransferCoefficient((double)value, fromUnit);
+            return new HeatTransferCoefficient(value, fromUnit);
         }
 
         #endregion
@@ -738,15 +732,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is HeatTransferCoefficientUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatTransferCoefficientUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is HeatTransferCoefficientUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatTransferCoefficientUnit)} is supported.", nameof(unit));
@@ -871,18 +856,6 @@ public HeatTransferCoefficient ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<HeatTransferCoefficientUnit> IQuantity<HeatTransferCoefficientUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not HeatTransferCoefficientUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(HeatTransferCoefficientUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
index 52e4d540ce..c35b8a1fe1 100644
--- a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Illuminance :
-        IArithmeticQuantity<Illuminance, IlluminanceUnit, double>,
+        IArithmeticQuantity<Illuminance, IlluminanceUnit>,
         IComparable,
         IComparable<Illuminance>,
         IConvertible,
@@ -153,7 +153,7 @@ public Illuminance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -248,40 +248,36 @@ public static string GetAbbreviation(IlluminanceUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Kilolux"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromKilolux(QuantityValue kilolux)
+        public static Illuminance FromKilolux(double kilolux)
         {
-            double value = (double) kilolux;
-            return new Illuminance(value, IlluminanceUnit.Kilolux);
+            return new Illuminance(kilolux, IlluminanceUnit.Kilolux);
         }
 
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Lux"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromLux(QuantityValue lux)
+        public static Illuminance FromLux(double lux)
         {
-            double value = (double) lux;
-            return new Illuminance(value, IlluminanceUnit.Lux);
+            return new Illuminance(lux, IlluminanceUnit.Lux);
         }
 
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Megalux"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromMegalux(QuantityValue megalux)
+        public static Illuminance FromMegalux(double megalux)
         {
-            double value = (double) megalux;
-            return new Illuminance(value, IlluminanceUnit.Megalux);
+            return new Illuminance(megalux, IlluminanceUnit.Megalux);
         }
 
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Millilux"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromMillilux(QuantityValue millilux)
+        public static Illuminance FromMillilux(double millilux)
         {
-            double value = (double) millilux;
-            return new Illuminance(value, IlluminanceUnit.Millilux);
+            return new Illuminance(millilux, IlluminanceUnit.Millilux);
         }
 
         /// <summary>
@@ -290,9 +286,9 @@ public static Illuminance FromMillilux(QuantityValue millilux)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Illuminance unit value.</returns>
-        public static Illuminance From(QuantityValue value, IlluminanceUnit fromUnit)
+        public static Illuminance From(double value, IlluminanceUnit fromUnit)
         {
-            return new Illuminance((double)value, fromUnit);
+            return new Illuminance(value, fromUnit);
         }
 
         #endregion
@@ -703,15 +699,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is IlluminanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IlluminanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is IlluminanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IlluminanceUnit)} is supported.", nameof(unit));
@@ -832,18 +819,6 @@ public Illuminance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<IlluminanceUnit> IQuantity<IlluminanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not IlluminanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IlluminanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs b/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
index 014956a017..4981926abc 100644
--- a/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Impulse :
-        IArithmeticQuantity<Impulse, ImpulseUnit, double>,
+        IArithmeticQuantity<Impulse, ImpulseUnit>,
         IComparable,
         IComparable<Impulse>,
         IConvertible,
@@ -159,7 +159,7 @@ public Impulse(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -317,130 +317,117 @@ public static string GetAbbreviation(ImpulseUnit unit, IFormatProvider? provider
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.CentinewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromCentinewtonSeconds(QuantityValue centinewtonseconds)
+        public static Impulse FromCentinewtonSeconds(double centinewtonseconds)
         {
-            double value = (double) centinewtonseconds;
-            return new Impulse(value, ImpulseUnit.CentinewtonSecond);
+            return new Impulse(centinewtonseconds, ImpulseUnit.CentinewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.DecanewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromDecanewtonSeconds(QuantityValue decanewtonseconds)
+        public static Impulse FromDecanewtonSeconds(double decanewtonseconds)
         {
-            double value = (double) decanewtonseconds;
-            return new Impulse(value, ImpulseUnit.DecanewtonSecond);
+            return new Impulse(decanewtonseconds, ImpulseUnit.DecanewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.DecinewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromDecinewtonSeconds(QuantityValue decinewtonseconds)
+        public static Impulse FromDecinewtonSeconds(double decinewtonseconds)
         {
-            double value = (double) decinewtonseconds;
-            return new Impulse(value, ImpulseUnit.DecinewtonSecond);
+            return new Impulse(decinewtonseconds, ImpulseUnit.DecinewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.KilogramMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromKilogramMetersPerSecond(QuantityValue kilogrammeterspersecond)
+        public static Impulse FromKilogramMetersPerSecond(double kilogrammeterspersecond)
         {
-            double value = (double) kilogrammeterspersecond;
-            return new Impulse(value, ImpulseUnit.KilogramMeterPerSecond);
+            return new Impulse(kilogrammeterspersecond, ImpulseUnit.KilogramMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.KilonewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromKilonewtonSeconds(QuantityValue kilonewtonseconds)
+        public static Impulse FromKilonewtonSeconds(double kilonewtonseconds)
         {
-            double value = (double) kilonewtonseconds;
-            return new Impulse(value, ImpulseUnit.KilonewtonSecond);
+            return new Impulse(kilonewtonseconds, ImpulseUnit.KilonewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MeganewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromMeganewtonSeconds(QuantityValue meganewtonseconds)
+        public static Impulse FromMeganewtonSeconds(double meganewtonseconds)
         {
-            double value = (double) meganewtonseconds;
-            return new Impulse(value, ImpulseUnit.MeganewtonSecond);
+            return new Impulse(meganewtonseconds, ImpulseUnit.MeganewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MicronewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromMicronewtonSeconds(QuantityValue micronewtonseconds)
+        public static Impulse FromMicronewtonSeconds(double micronewtonseconds)
         {
-            double value = (double) micronewtonseconds;
-            return new Impulse(value, ImpulseUnit.MicronewtonSecond);
+            return new Impulse(micronewtonseconds, ImpulseUnit.MicronewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MillinewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromMillinewtonSeconds(QuantityValue millinewtonseconds)
+        public static Impulse FromMillinewtonSeconds(double millinewtonseconds)
         {
-            double value = (double) millinewtonseconds;
-            return new Impulse(value, ImpulseUnit.MillinewtonSecond);
+            return new Impulse(millinewtonseconds, ImpulseUnit.MillinewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.NanonewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromNanonewtonSeconds(QuantityValue nanonewtonseconds)
+        public static Impulse FromNanonewtonSeconds(double nanonewtonseconds)
         {
-            double value = (double) nanonewtonseconds;
-            return new Impulse(value, ImpulseUnit.NanonewtonSecond);
+            return new Impulse(nanonewtonseconds, ImpulseUnit.NanonewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.NewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromNewtonSeconds(QuantityValue newtonseconds)
+        public static Impulse FromNewtonSeconds(double newtonseconds)
         {
-            double value = (double) newtonseconds;
-            return new Impulse(value, ImpulseUnit.NewtonSecond);
+            return new Impulse(newtonseconds, ImpulseUnit.NewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.PoundFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromPoundFeetPerSecond(QuantityValue poundfeetpersecond)
+        public static Impulse FromPoundFeetPerSecond(double poundfeetpersecond)
         {
-            double value = (double) poundfeetpersecond;
-            return new Impulse(value, ImpulseUnit.PoundFootPerSecond);
+            return new Impulse(poundfeetpersecond, ImpulseUnit.PoundFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.PoundForceSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromPoundForceSeconds(QuantityValue poundforceseconds)
+        public static Impulse FromPoundForceSeconds(double poundforceseconds)
         {
-            double value = (double) poundforceseconds;
-            return new Impulse(value, ImpulseUnit.PoundForceSecond);
+            return new Impulse(poundforceseconds, ImpulseUnit.PoundForceSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.SlugFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromSlugFeetPerSecond(QuantityValue slugfeetpersecond)
+        public static Impulse FromSlugFeetPerSecond(double slugfeetpersecond)
         {
-            double value = (double) slugfeetpersecond;
-            return new Impulse(value, ImpulseUnit.SlugFootPerSecond);
+            return new Impulse(slugfeetpersecond, ImpulseUnit.SlugFootPerSecond);
         }
 
         /// <summary>
@@ -449,9 +436,9 @@ public static Impulse FromSlugFeetPerSecond(QuantityValue slugfeetpersecond)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Impulse unit value.</returns>
-        public static Impulse From(QuantityValue value, ImpulseUnit fromUnit)
+        public static Impulse From(double value, ImpulseUnit fromUnit)
         {
-            return new Impulse((double)value, fromUnit);
+            return new Impulse(value, fromUnit);
         }
 
         #endregion
@@ -862,15 +849,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ImpulseUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ImpulseUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ImpulseUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ImpulseUnit)} is supported.", nameof(unit));
@@ -1009,18 +987,6 @@ public Impulse ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ImpulseUnit> IQuantity<ImpulseUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ImpulseUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ImpulseUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
index 36dcc10bf3..892c978953 100644
--- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Information :
-        IArithmeticQuantity<Information, InformationUnit, double>,
+        IArithmeticQuantity<Information, InformationUnit>,
         IComparable,
         IComparable<Information>,
         IConvertible,
@@ -172,7 +172,7 @@ public Information(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -421,260 +421,234 @@ public static string GetAbbreviation(InformationUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Bit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromBits(QuantityValue bits)
+        public static Information FromBits(double bits)
         {
-            double value = (double) bits;
-            return new Information(value, InformationUnit.Bit);
+            return new Information(bits, InformationUnit.Bit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Byte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromBytes(QuantityValue bytes)
+        public static Information FromBytes(double bytes)
         {
-            double value = (double) bytes;
-            return new Information(value, InformationUnit.Byte);
+            return new Information(bytes, InformationUnit.Byte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExabits(QuantityValue exabits)
+        public static Information FromExabits(double exabits)
         {
-            double value = (double) exabits;
-            return new Information(value, InformationUnit.Exabit);
+            return new Information(exabits, InformationUnit.Exabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExabytes(QuantityValue exabytes)
+        public static Information FromExabytes(double exabytes)
         {
-            double value = (double) exabytes;
-            return new Information(value, InformationUnit.Exabyte);
+            return new Information(exabytes, InformationUnit.Exabyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExbibits(QuantityValue exbibits)
+        public static Information FromExbibits(double exbibits)
         {
-            double value = (double) exbibits;
-            return new Information(value, InformationUnit.Exbibit);
+            return new Information(exbibits, InformationUnit.Exbibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExbibytes(QuantityValue exbibytes)
+        public static Information FromExbibytes(double exbibytes)
         {
-            double value = (double) exbibytes;
-            return new Information(value, InformationUnit.Exbibyte);
+            return new Information(exbibytes, InformationUnit.Exbibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGibibits(QuantityValue gibibits)
+        public static Information FromGibibits(double gibibits)
         {
-            double value = (double) gibibits;
-            return new Information(value, InformationUnit.Gibibit);
+            return new Information(gibibits, InformationUnit.Gibibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGibibytes(QuantityValue gibibytes)
+        public static Information FromGibibytes(double gibibytes)
         {
-            double value = (double) gibibytes;
-            return new Information(value, InformationUnit.Gibibyte);
+            return new Information(gibibytes, InformationUnit.Gibibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGigabits(QuantityValue gigabits)
+        public static Information FromGigabits(double gigabits)
         {
-            double value = (double) gigabits;
-            return new Information(value, InformationUnit.Gigabit);
+            return new Information(gigabits, InformationUnit.Gigabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGigabytes(QuantityValue gigabytes)
+        public static Information FromGigabytes(double gigabytes)
         {
-            double value = (double) gigabytes;
-            return new Information(value, InformationUnit.Gigabyte);
+            return new Information(gigabytes, InformationUnit.Gigabyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKibibits(QuantityValue kibibits)
+        public static Information FromKibibits(double kibibits)
         {
-            double value = (double) kibibits;
-            return new Information(value, InformationUnit.Kibibit);
+            return new Information(kibibits, InformationUnit.Kibibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKibibytes(QuantityValue kibibytes)
+        public static Information FromKibibytes(double kibibytes)
         {
-            double value = (double) kibibytes;
-            return new Information(value, InformationUnit.Kibibyte);
+            return new Information(kibibytes, InformationUnit.Kibibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilobit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKilobits(QuantityValue kilobits)
+        public static Information FromKilobits(double kilobits)
         {
-            double value = (double) kilobits;
-            return new Information(value, InformationUnit.Kilobit);
+            return new Information(kilobits, InformationUnit.Kilobit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilobyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKilobytes(QuantityValue kilobytes)
+        public static Information FromKilobytes(double kilobytes)
         {
-            double value = (double) kilobytes;
-            return new Information(value, InformationUnit.Kilobyte);
+            return new Information(kilobytes, InformationUnit.Kilobyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMebibits(QuantityValue mebibits)
+        public static Information FromMebibits(double mebibits)
         {
-            double value = (double) mebibits;
-            return new Information(value, InformationUnit.Mebibit);
+            return new Information(mebibits, InformationUnit.Mebibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMebibytes(QuantityValue mebibytes)
+        public static Information FromMebibytes(double mebibytes)
         {
-            double value = (double) mebibytes;
-            return new Information(value, InformationUnit.Mebibyte);
+            return new Information(mebibytes, InformationUnit.Mebibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMegabits(QuantityValue megabits)
+        public static Information FromMegabits(double megabits)
         {
-            double value = (double) megabits;
-            return new Information(value, InformationUnit.Megabit);
+            return new Information(megabits, InformationUnit.Megabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMegabytes(QuantityValue megabytes)
+        public static Information FromMegabytes(double megabytes)
         {
-            double value = (double) megabytes;
-            return new Information(value, InformationUnit.Megabyte);
+            return new Information(megabytes, InformationUnit.Megabyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPebibits(QuantityValue pebibits)
+        public static Information FromPebibits(double pebibits)
         {
-            double value = (double) pebibits;
-            return new Information(value, InformationUnit.Pebibit);
+            return new Information(pebibits, InformationUnit.Pebibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPebibytes(QuantityValue pebibytes)
+        public static Information FromPebibytes(double pebibytes)
         {
-            double value = (double) pebibytes;
-            return new Information(value, InformationUnit.Pebibyte);
+            return new Information(pebibytes, InformationUnit.Pebibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPetabits(QuantityValue petabits)
+        public static Information FromPetabits(double petabits)
         {
-            double value = (double) petabits;
-            return new Information(value, InformationUnit.Petabit);
+            return new Information(petabits, InformationUnit.Petabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPetabytes(QuantityValue petabytes)
+        public static Information FromPetabytes(double petabytes)
         {
-            double value = (double) petabytes;
-            return new Information(value, InformationUnit.Petabyte);
+            return new Information(petabytes, InformationUnit.Petabyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTebibits(QuantityValue tebibits)
+        public static Information FromTebibits(double tebibits)
         {
-            double value = (double) tebibits;
-            return new Information(value, InformationUnit.Tebibit);
+            return new Information(tebibits, InformationUnit.Tebibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTebibytes(QuantityValue tebibytes)
+        public static Information FromTebibytes(double tebibytes)
         {
-            double value = (double) tebibytes;
-            return new Information(value, InformationUnit.Tebibyte);
+            return new Information(tebibytes, InformationUnit.Tebibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Terabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTerabits(QuantityValue terabits)
+        public static Information FromTerabits(double terabits)
         {
-            double value = (double) terabits;
-            return new Information(value, InformationUnit.Terabit);
+            return new Information(terabits, InformationUnit.Terabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Terabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTerabytes(QuantityValue terabytes)
+        public static Information FromTerabytes(double terabytes)
         {
-            double value = (double) terabytes;
-            return new Information(value, InformationUnit.Terabyte);
+            return new Information(terabytes, InformationUnit.Terabyte);
         }
 
         /// <summary>
@@ -683,9 +657,9 @@ public static Information FromTerabytes(QuantityValue terabytes)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Information unit value.</returns>
-        public static Information From(QuantityValue value, InformationUnit fromUnit)
+        public static Information From(double value, InformationUnit fromUnit)
         {
-            return new Information((double)value, fromUnit);
+            return new Information(value, fromUnit);
         }
 
         #endregion
@@ -1096,15 +1070,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is InformationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(InformationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is InformationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(InformationUnit)} is supported.", nameof(unit));
@@ -1269,18 +1234,6 @@ public Information ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<InformationUnit> IQuantity<InformationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not InformationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(InformationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
index 678bc160ba..fa1233967f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Irradiance :
-        IArithmeticQuantity<Irradiance, IrradianceUnit, double>,
+        IArithmeticQuantity<Irradiance, IrradianceUnit>,
         IComparable,
         IComparable<Irradiance>,
         IConvertible,
@@ -160,7 +160,7 @@ public Irradiance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -325,140 +325,126 @@ public static string GetAbbreviation(IrradianceUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.KilowattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromKilowattsPerSquareCentimeter(QuantityValue kilowattspersquarecentimeter)
+        public static Irradiance FromKilowattsPerSquareCentimeter(double kilowattspersquarecentimeter)
         {
-            double value = (double) kilowattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.KilowattPerSquareCentimeter);
+            return new Irradiance(kilowattspersquarecentimeter, IrradianceUnit.KilowattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.KilowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromKilowattsPerSquareMeter(QuantityValue kilowattspersquaremeter)
+        public static Irradiance FromKilowattsPerSquareMeter(double kilowattspersquaremeter)
         {
-            double value = (double) kilowattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.KilowattPerSquareMeter);
+            return new Irradiance(kilowattspersquaremeter, IrradianceUnit.KilowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MegawattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMegawattsPerSquareCentimeter(QuantityValue megawattspersquarecentimeter)
+        public static Irradiance FromMegawattsPerSquareCentimeter(double megawattspersquarecentimeter)
         {
-            double value = (double) megawattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.MegawattPerSquareCentimeter);
+            return new Irradiance(megawattspersquarecentimeter, IrradianceUnit.MegawattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MegawattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMegawattsPerSquareMeter(QuantityValue megawattspersquaremeter)
+        public static Irradiance FromMegawattsPerSquareMeter(double megawattspersquaremeter)
         {
-            double value = (double) megawattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.MegawattPerSquareMeter);
+            return new Irradiance(megawattspersquaremeter, IrradianceUnit.MegawattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MicrowattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMicrowattsPerSquareCentimeter(QuantityValue microwattspersquarecentimeter)
+        public static Irradiance FromMicrowattsPerSquareCentimeter(double microwattspersquarecentimeter)
         {
-            double value = (double) microwattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.MicrowattPerSquareCentimeter);
+            return new Irradiance(microwattspersquarecentimeter, IrradianceUnit.MicrowattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MicrowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMicrowattsPerSquareMeter(QuantityValue microwattspersquaremeter)
+        public static Irradiance FromMicrowattsPerSquareMeter(double microwattspersquaremeter)
         {
-            double value = (double) microwattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.MicrowattPerSquareMeter);
+            return new Irradiance(microwattspersquaremeter, IrradianceUnit.MicrowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MilliwattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMilliwattsPerSquareCentimeter(QuantityValue milliwattspersquarecentimeter)
+        public static Irradiance FromMilliwattsPerSquareCentimeter(double milliwattspersquarecentimeter)
         {
-            double value = (double) milliwattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.MilliwattPerSquareCentimeter);
+            return new Irradiance(milliwattspersquarecentimeter, IrradianceUnit.MilliwattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MilliwattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMilliwattsPerSquareMeter(QuantityValue milliwattspersquaremeter)
+        public static Irradiance FromMilliwattsPerSquareMeter(double milliwattspersquaremeter)
         {
-            double value = (double) milliwattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.MilliwattPerSquareMeter);
+            return new Irradiance(milliwattspersquaremeter, IrradianceUnit.MilliwattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.NanowattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromNanowattsPerSquareCentimeter(QuantityValue nanowattspersquarecentimeter)
+        public static Irradiance FromNanowattsPerSquareCentimeter(double nanowattspersquarecentimeter)
         {
-            double value = (double) nanowattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.NanowattPerSquareCentimeter);
+            return new Irradiance(nanowattspersquarecentimeter, IrradianceUnit.NanowattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.NanowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromNanowattsPerSquareMeter(QuantityValue nanowattspersquaremeter)
+        public static Irradiance FromNanowattsPerSquareMeter(double nanowattspersquaremeter)
         {
-            double value = (double) nanowattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.NanowattPerSquareMeter);
+            return new Irradiance(nanowattspersquaremeter, IrradianceUnit.NanowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.PicowattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromPicowattsPerSquareCentimeter(QuantityValue picowattspersquarecentimeter)
+        public static Irradiance FromPicowattsPerSquareCentimeter(double picowattspersquarecentimeter)
         {
-            double value = (double) picowattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.PicowattPerSquareCentimeter);
+            return new Irradiance(picowattspersquarecentimeter, IrradianceUnit.PicowattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.PicowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromPicowattsPerSquareMeter(QuantityValue picowattspersquaremeter)
+        public static Irradiance FromPicowattsPerSquareMeter(double picowattspersquaremeter)
         {
-            double value = (double) picowattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.PicowattPerSquareMeter);
+            return new Irradiance(picowattspersquaremeter, IrradianceUnit.PicowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.WattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromWattsPerSquareCentimeter(QuantityValue wattspersquarecentimeter)
+        public static Irradiance FromWattsPerSquareCentimeter(double wattspersquarecentimeter)
         {
-            double value = (double) wattspersquarecentimeter;
-            return new Irradiance(value, IrradianceUnit.WattPerSquareCentimeter);
+            return new Irradiance(wattspersquarecentimeter, IrradianceUnit.WattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.WattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromWattsPerSquareMeter(QuantityValue wattspersquaremeter)
+        public static Irradiance FromWattsPerSquareMeter(double wattspersquaremeter)
         {
-            double value = (double) wattspersquaremeter;
-            return new Irradiance(value, IrradianceUnit.WattPerSquareMeter);
+            return new Irradiance(wattspersquaremeter, IrradianceUnit.WattPerSquareMeter);
         }
 
         /// <summary>
@@ -467,9 +453,9 @@ public static Irradiance FromWattsPerSquareMeter(QuantityValue wattspersquaremet
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Irradiance unit value.</returns>
-        public static Irradiance From(QuantityValue value, IrradianceUnit fromUnit)
+        public static Irradiance From(double value, IrradianceUnit fromUnit)
         {
-            return new Irradiance((double)value, fromUnit);
+            return new Irradiance(value, fromUnit);
         }
 
         #endregion
@@ -880,15 +866,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is IrradianceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradianceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is IrradianceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradianceUnit)} is supported.", nameof(unit));
@@ -1029,18 +1006,6 @@ public Irradiance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<IrradianceUnit> IQuantity<IrradianceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not IrradianceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradianceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
index e218c44001..9d294e4e23 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Irradiation :
-        IArithmeticQuantity<Irradiation, IrradiationUnit, double>,
+        IArithmeticQuantity<Irradiation, IrradiationUnit>,
         IComparable,
         IComparable<Irradiation>,
         IConvertible,
@@ -156,7 +156,7 @@ public Irradiation(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -272,70 +272,63 @@ public static string GetAbbreviation(IrradiationUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareCentimeter(QuantityValue joulespersquarecentimeter)
+        public static Irradiation FromJoulesPerSquareCentimeter(double joulespersquarecentimeter)
         {
-            double value = (double) joulespersquarecentimeter;
-            return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter);
+            return new Irradiation(joulespersquarecentimeter, IrradiationUnit.JoulePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareMeter(QuantityValue joulespersquaremeter)
+        public static Irradiation FromJoulesPerSquareMeter(double joulespersquaremeter)
         {
-            double value = (double) joulespersquaremeter;
-            return new Irradiation(value, IrradiationUnit.JoulePerSquareMeter);
+            return new Irradiation(joulespersquaremeter, IrradiationUnit.JoulePerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareMillimeter(QuantityValue joulespersquaremillimeter)
+        public static Irradiation FromJoulesPerSquareMillimeter(double joulespersquaremillimeter)
         {
-            double value = (double) joulespersquaremillimeter;
-            return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter);
+            return new Irradiation(joulespersquaremillimeter, IrradiationUnit.JoulePerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilojoulePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromKilojoulesPerSquareMeter(QuantityValue kilojoulespersquaremeter)
+        public static Irradiation FromKilojoulesPerSquareMeter(double kilojoulespersquaremeter)
         {
-            double value = (double) kilojoulespersquaremeter;
-            return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter);
+            return new Irradiation(kilojoulespersquaremeter, IrradiationUnit.KilojoulePerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilowattHourPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromKilowattHoursPerSquareMeter(QuantityValue kilowatthourspersquaremeter)
+        public static Irradiation FromKilowattHoursPerSquareMeter(double kilowatthourspersquaremeter)
         {
-            double value = (double) kilowatthourspersquaremeter;
-            return new Irradiation(value, IrradiationUnit.KilowattHourPerSquareMeter);
+            return new Irradiation(kilowatthourspersquaremeter, IrradiationUnit.KilowattHourPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.MillijoulePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromMillijoulesPerSquareCentimeter(QuantityValue millijoulespersquarecentimeter)
+        public static Irradiation FromMillijoulesPerSquareCentimeter(double millijoulespersquarecentimeter)
         {
-            double value = (double) millijoulespersquarecentimeter;
-            return new Irradiation(value, IrradiationUnit.MillijoulePerSquareCentimeter);
+            return new Irradiation(millijoulespersquarecentimeter, IrradiationUnit.MillijoulePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.WattHourPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromWattHoursPerSquareMeter(QuantityValue watthourspersquaremeter)
+        public static Irradiation FromWattHoursPerSquareMeter(double watthourspersquaremeter)
         {
-            double value = (double) watthourspersquaremeter;
-            return new Irradiation(value, IrradiationUnit.WattHourPerSquareMeter);
+            return new Irradiation(watthourspersquaremeter, IrradiationUnit.WattHourPerSquareMeter);
         }
 
         /// <summary>
@@ -344,9 +337,9 @@ public static Irradiation FromWattHoursPerSquareMeter(QuantityValue watthoursper
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Irradiation unit value.</returns>
-        public static Irradiation From(QuantityValue value, IrradiationUnit fromUnit)
+        public static Irradiation From(double value, IrradiationUnit fromUnit)
         {
-            return new Irradiation((double)value, fromUnit);
+            return new Irradiation(value, fromUnit);
         }
 
         #endregion
@@ -757,15 +750,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is IrradiationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradiationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is IrradiationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradiationUnit)} is supported.", nameof(unit));
@@ -892,18 +876,6 @@ public Irradiation ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<IrradiationUnit> IQuantity<IrradiationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not IrradiationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(IrradiationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs b/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
index 5ea97824d3..473fb34652 100644
--- a/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Jerk :
-        IArithmeticQuantity<Jerk, JerkUnit, double>,
+        IArithmeticQuantity<Jerk, JerkUnit>,
         IComparable,
         IComparable<Jerk>,
         IConvertible,
@@ -157,7 +157,7 @@ public Jerk(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -301,110 +301,99 @@ public static string GetAbbreviation(JerkUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.CentimeterPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromCentimetersPerSecondCubed(QuantityValue centimeterspersecondcubed)
+        public static Jerk FromCentimetersPerSecondCubed(double centimeterspersecondcubed)
         {
-            double value = (double) centimeterspersecondcubed;
-            return new Jerk(value, JerkUnit.CentimeterPerSecondCubed);
+            return new Jerk(centimeterspersecondcubed, JerkUnit.CentimeterPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.DecimeterPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromDecimetersPerSecondCubed(QuantityValue decimeterspersecondcubed)
+        public static Jerk FromDecimetersPerSecondCubed(double decimeterspersecondcubed)
         {
-            double value = (double) decimeterspersecondcubed;
-            return new Jerk(value, JerkUnit.DecimeterPerSecondCubed);
+            return new Jerk(decimeterspersecondcubed, JerkUnit.DecimeterPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.FootPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromFeetPerSecondCubed(QuantityValue feetpersecondcubed)
+        public static Jerk FromFeetPerSecondCubed(double feetpersecondcubed)
         {
-            double value = (double) feetpersecondcubed;
-            return new Jerk(value, JerkUnit.FootPerSecondCubed);
+            return new Jerk(feetpersecondcubed, JerkUnit.FootPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.InchPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromInchesPerSecondCubed(QuantityValue inchespersecondcubed)
+        public static Jerk FromInchesPerSecondCubed(double inchespersecondcubed)
         {
-            double value = (double) inchespersecondcubed;
-            return new Jerk(value, JerkUnit.InchPerSecondCubed);
+            return new Jerk(inchespersecondcubed, JerkUnit.InchPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.KilometerPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromKilometersPerSecondCubed(QuantityValue kilometerspersecondcubed)
+        public static Jerk FromKilometersPerSecondCubed(double kilometerspersecondcubed)
         {
-            double value = (double) kilometerspersecondcubed;
-            return new Jerk(value, JerkUnit.KilometerPerSecondCubed);
+            return new Jerk(kilometerspersecondcubed, JerkUnit.KilometerPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MeterPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromMetersPerSecondCubed(QuantityValue meterspersecondcubed)
+        public static Jerk FromMetersPerSecondCubed(double meterspersecondcubed)
         {
-            double value = (double) meterspersecondcubed;
-            return new Jerk(value, JerkUnit.MeterPerSecondCubed);
+            return new Jerk(meterspersecondcubed, JerkUnit.MeterPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MicrometerPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromMicrometersPerSecondCubed(QuantityValue micrometerspersecondcubed)
+        public static Jerk FromMicrometersPerSecondCubed(double micrometerspersecondcubed)
         {
-            double value = (double) micrometerspersecondcubed;
-            return new Jerk(value, JerkUnit.MicrometerPerSecondCubed);
+            return new Jerk(micrometerspersecondcubed, JerkUnit.MicrometerPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MillimeterPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromMillimetersPerSecondCubed(QuantityValue millimeterspersecondcubed)
+        public static Jerk FromMillimetersPerSecondCubed(double millimeterspersecondcubed)
         {
-            double value = (double) millimeterspersecondcubed;
-            return new Jerk(value, JerkUnit.MillimeterPerSecondCubed);
+            return new Jerk(millimeterspersecondcubed, JerkUnit.MillimeterPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MillistandardGravitiesPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromMillistandardGravitiesPerSecond(QuantityValue millistandardgravitiespersecond)
+        public static Jerk FromMillistandardGravitiesPerSecond(double millistandardgravitiespersecond)
         {
-            double value = (double) millistandardgravitiespersecond;
-            return new Jerk(value, JerkUnit.MillistandardGravitiesPerSecond);
+            return new Jerk(millistandardgravitiespersecond, JerkUnit.MillistandardGravitiesPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.NanometerPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromNanometersPerSecondCubed(QuantityValue nanometerspersecondcubed)
+        public static Jerk FromNanometersPerSecondCubed(double nanometerspersecondcubed)
         {
-            double value = (double) nanometerspersecondcubed;
-            return new Jerk(value, JerkUnit.NanometerPerSecondCubed);
+            return new Jerk(nanometerspersecondcubed, JerkUnit.NanometerPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.StandardGravitiesPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromStandardGravitiesPerSecond(QuantityValue standardgravitiespersecond)
+        public static Jerk FromStandardGravitiesPerSecond(double standardgravitiespersecond)
         {
-            double value = (double) standardgravitiespersecond;
-            return new Jerk(value, JerkUnit.StandardGravitiesPerSecond);
+            return new Jerk(standardgravitiespersecond, JerkUnit.StandardGravitiesPerSecond);
         }
 
         /// <summary>
@@ -413,9 +402,9 @@ public static Jerk FromStandardGravitiesPerSecond(QuantityValue standardgravitie
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Jerk unit value.</returns>
-        public static Jerk From(QuantityValue value, JerkUnit fromUnit)
+        public static Jerk From(double value, JerkUnit fromUnit)
         {
-            return new Jerk((double)value, fromUnit);
+            return new Jerk(value, fromUnit);
         }
 
         #endregion
@@ -826,15 +815,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is JerkUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(JerkUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is JerkUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(JerkUnit)} is supported.", nameof(unit));
@@ -969,18 +949,6 @@ public Jerk ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<JerkUnit> IQuantity<JerkUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not JerkUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(JerkUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
index cc7dc19d31..0988035e9f 100644
--- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct KinematicViscosity :
-        IArithmeticQuantity<KinematicViscosity, KinematicViscosityUnit, double>,
+        IArithmeticQuantity<KinematicViscosity, KinematicViscosityUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<KinematicViscosity, Duration, Area>,
         IMultiplyOperators<KinematicViscosity, TimeSpan, Area>,
@@ -167,7 +167,7 @@ public KinematicViscosity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -297,90 +297,81 @@ public static string GetAbbreviation(KinematicViscosityUnit unit, IFormatProvide
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Centistokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromCentistokes(QuantityValue centistokes)
+        public static KinematicViscosity FromCentistokes(double centistokes)
         {
-            double value = (double) centistokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Centistokes);
+            return new KinematicViscosity(centistokes, KinematicViscosityUnit.Centistokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Decistokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromDecistokes(QuantityValue decistokes)
+        public static KinematicViscosity FromDecistokes(double decistokes)
         {
-            double value = (double) decistokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Decistokes);
+            return new KinematicViscosity(decistokes, KinematicViscosityUnit.Decistokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Kilostokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromKilostokes(QuantityValue kilostokes)
+        public static KinematicViscosity FromKilostokes(double kilostokes)
         {
-            double value = (double) kilostokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Kilostokes);
+            return new KinematicViscosity(kilostokes, KinematicViscosityUnit.Kilostokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Microstokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromMicrostokes(QuantityValue microstokes)
+        public static KinematicViscosity FromMicrostokes(double microstokes)
         {
-            double value = (double) microstokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Microstokes);
+            return new KinematicViscosity(microstokes, KinematicViscosityUnit.Microstokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Millistokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromMillistokes(QuantityValue millistokes)
+        public static KinematicViscosity FromMillistokes(double millistokes)
         {
-            double value = (double) millistokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Millistokes);
+            return new KinematicViscosity(millistokes, KinematicViscosityUnit.Millistokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Nanostokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromNanostokes(QuantityValue nanostokes)
+        public static KinematicViscosity FromNanostokes(double nanostokes)
         {
-            double value = (double) nanostokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Nanostokes);
+            return new KinematicViscosity(nanostokes, KinematicViscosityUnit.Nanostokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.SquareFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromSquareFeetPerSecond(QuantityValue squarefeetpersecond)
+        public static KinematicViscosity FromSquareFeetPerSecond(double squarefeetpersecond)
         {
-            double value = (double) squarefeetpersecond;
-            return new KinematicViscosity(value, KinematicViscosityUnit.SquareFootPerSecond);
+            return new KinematicViscosity(squarefeetpersecond, KinematicViscosityUnit.SquareFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.SquareMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromSquareMetersPerSecond(QuantityValue squaremeterspersecond)
+        public static KinematicViscosity FromSquareMetersPerSecond(double squaremeterspersecond)
         {
-            double value = (double) squaremeterspersecond;
-            return new KinematicViscosity(value, KinematicViscosityUnit.SquareMeterPerSecond);
+            return new KinematicViscosity(squaremeterspersecond, KinematicViscosityUnit.SquareMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Stokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromStokes(QuantityValue stokes)
+        public static KinematicViscosity FromStokes(double stokes)
         {
-            double value = (double) stokes;
-            return new KinematicViscosity(value, KinematicViscosityUnit.Stokes);
+            return new KinematicViscosity(stokes, KinematicViscosityUnit.Stokes);
         }
 
         /// <summary>
@@ -389,9 +380,9 @@ public static KinematicViscosity FromStokes(QuantityValue stokes)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>KinematicViscosity unit value.</returns>
-        public static KinematicViscosity From(QuantityValue value, KinematicViscosityUnit fromUnit)
+        public static KinematicViscosity From(double value, KinematicViscosityUnit fromUnit)
         {
-            return new KinematicViscosity((double)value, fromUnit);
+            return new KinematicViscosity(value, fromUnit);
         }
 
         #endregion
@@ -836,15 +827,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is KinematicViscosityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(KinematicViscosityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is KinematicViscosityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(KinematicViscosityUnit)} is supported.", nameof(unit));
@@ -975,18 +957,6 @@ public KinematicViscosity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<KinematicViscosityUnit> IQuantity<KinematicViscosityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not KinematicViscosityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(KinematicViscosityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs b/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
index 01406342cf..0c6ea0fdfe 100644
--- a/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct LeakRate :
-        IArithmeticQuantity<LeakRate, LeakRateUnit, double>,
+        IArithmeticQuantity<LeakRate, LeakRateUnit>,
         IComparable,
         IComparable<LeakRate>,
         IConvertible,
@@ -152,7 +152,7 @@ public LeakRate(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -240,30 +240,27 @@ public static string GetAbbreviation(LeakRateUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.MillibarLiterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LeakRate FromMillibarLitersPerSecond(QuantityValue millibarliterspersecond)
+        public static LeakRate FromMillibarLitersPerSecond(double millibarliterspersecond)
         {
-            double value = (double) millibarliterspersecond;
-            return new LeakRate(value, LeakRateUnit.MillibarLiterPerSecond);
+            return new LeakRate(millibarliterspersecond, LeakRateUnit.MillibarLiterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.PascalCubicMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LeakRate FromPascalCubicMetersPerSecond(QuantityValue pascalcubicmeterspersecond)
+        public static LeakRate FromPascalCubicMetersPerSecond(double pascalcubicmeterspersecond)
         {
-            double value = (double) pascalcubicmeterspersecond;
-            return new LeakRate(value, LeakRateUnit.PascalCubicMeterPerSecond);
+            return new LeakRate(pascalcubicmeterspersecond, LeakRateUnit.PascalCubicMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.TorrLiterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LeakRate FromTorrLitersPerSecond(QuantityValue torrliterspersecond)
+        public static LeakRate FromTorrLitersPerSecond(double torrliterspersecond)
         {
-            double value = (double) torrliterspersecond;
-            return new LeakRate(value, LeakRateUnit.TorrLiterPerSecond);
+            return new LeakRate(torrliterspersecond, LeakRateUnit.TorrLiterPerSecond);
         }
 
         /// <summary>
@@ -272,9 +269,9 @@ public static LeakRate FromTorrLitersPerSecond(QuantityValue torrliterspersecond
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LeakRate unit value.</returns>
-        public static LeakRate From(QuantityValue value, LeakRateUnit fromUnit)
+        public static LeakRate From(double value, LeakRateUnit fromUnit)
         {
-            return new LeakRate((double)value, fromUnit);
+            return new LeakRate(value, fromUnit);
         }
 
         #endregion
@@ -685,15 +682,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LeakRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LeakRateUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LeakRateUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LeakRateUnit)} is supported.", nameof(unit));
@@ -812,18 +800,6 @@ public LeakRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LeakRateUnit> IQuantity<LeakRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LeakRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LeakRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
index e97ae64cdc..0a6d1841dd 100644
--- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Length :
-        IArithmeticQuantity<Length, LengthUnit, double>,
+        IArithmeticQuantity<Length, LengthUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Length, Length, Area>,
         IDivisionOperators<Length, Speed, Duration>,
@@ -205,7 +205,7 @@ public Length(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -566,420 +566,378 @@ public static string GetAbbreviation(LengthUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Angstrom"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromAngstroms(QuantityValue angstroms)
+        public static Length FromAngstroms(double angstroms)
         {
-            double value = (double) angstroms;
-            return new Length(value, LengthUnit.Angstrom);
+            return new Length(angstroms, LengthUnit.Angstrom);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.AstronomicalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromAstronomicalUnits(QuantityValue astronomicalunits)
+        public static Length FromAstronomicalUnits(double astronomicalunits)
         {
-            double value = (double) astronomicalunits;
-            return new Length(value, LengthUnit.AstronomicalUnit);
+            return new Length(astronomicalunits, LengthUnit.AstronomicalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Centimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromCentimeters(QuantityValue centimeters)
+        public static Length FromCentimeters(double centimeters)
         {
-            double value = (double) centimeters;
-            return new Length(value, LengthUnit.Centimeter);
+            return new Length(centimeters, LengthUnit.Centimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Chain"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromChains(QuantityValue chains)
+        public static Length FromChains(double chains)
         {
-            double value = (double) chains;
-            return new Length(value, LengthUnit.Chain);
+            return new Length(chains, LengthUnit.Chain);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DataMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDataMiles(QuantityValue datamiles)
+        public static Length FromDataMiles(double datamiles)
         {
-            double value = (double) datamiles;
-            return new Length(value, LengthUnit.DataMile);
+            return new Length(datamiles, LengthUnit.DataMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Decameter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDecameters(QuantityValue decameters)
+        public static Length FromDecameters(double decameters)
         {
-            double value = (double) decameters;
-            return new Length(value, LengthUnit.Decameter);
+            return new Length(decameters, LengthUnit.Decameter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Decimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDecimeters(QuantityValue decimeters)
+        public static Length FromDecimeters(double decimeters)
         {
-            double value = (double) decimeters;
-            return new Length(value, LengthUnit.Decimeter);
+            return new Length(decimeters, LengthUnit.Decimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DtpPica"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDtpPicas(QuantityValue dtppicas)
+        public static Length FromDtpPicas(double dtppicas)
         {
-            double value = (double) dtppicas;
-            return new Length(value, LengthUnit.DtpPica);
+            return new Length(dtppicas, LengthUnit.DtpPica);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DtpPoint"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDtpPoints(QuantityValue dtppoints)
+        public static Length FromDtpPoints(double dtppoints)
         {
-            double value = (double) dtppoints;
-            return new Length(value, LengthUnit.DtpPoint);
+            return new Length(dtppoints, LengthUnit.DtpPoint);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Fathom"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromFathoms(QuantityValue fathoms)
+        public static Length FromFathoms(double fathoms)
         {
-            double value = (double) fathoms;
-            return new Length(value, LengthUnit.Fathom);
+            return new Length(fathoms, LengthUnit.Fathom);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Femtometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromFemtometers(QuantityValue femtometers)
+        public static Length FromFemtometers(double femtometers)
         {
-            double value = (double) femtometers;
-            return new Length(value, LengthUnit.Femtometer);
+            return new Length(femtometers, LengthUnit.Femtometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Foot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromFeet(QuantityValue feet)
+        public static Length FromFeet(double feet)
         {
-            double value = (double) feet;
-            return new Length(value, LengthUnit.Foot);
+            return new Length(feet, LengthUnit.Foot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Gigameter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromGigameters(QuantityValue gigameters)
+        public static Length FromGigameters(double gigameters)
         {
-            double value = (double) gigameters;
-            return new Length(value, LengthUnit.Gigameter);
+            return new Length(gigameters, LengthUnit.Gigameter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Hand"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromHands(QuantityValue hands)
+        public static Length FromHands(double hands)
         {
-            double value = (double) hands;
-            return new Length(value, LengthUnit.Hand);
+            return new Length(hands, LengthUnit.Hand);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Hectometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromHectometers(QuantityValue hectometers)
+        public static Length FromHectometers(double hectometers)
         {
-            double value = (double) hectometers;
-            return new Length(value, LengthUnit.Hectometer);
+            return new Length(hectometers, LengthUnit.Hectometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Inch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromInches(QuantityValue inches)
+        public static Length FromInches(double inches)
         {
-            double value = (double) inches;
-            return new Length(value, LengthUnit.Inch);
+            return new Length(inches, LengthUnit.Inch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kilofoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKilofeet(QuantityValue kilofeet)
+        public static Length FromKilofeet(double kilofeet)
         {
-            double value = (double) kilofeet;
-            return new Length(value, LengthUnit.Kilofoot);
+            return new Length(kilofeet, LengthUnit.Kilofoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.KilolightYear"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKilolightYears(QuantityValue kilolightyears)
+        public static Length FromKilolightYears(double kilolightyears)
         {
-            double value = (double) kilolightyears;
-            return new Length(value, LengthUnit.KilolightYear);
+            return new Length(kilolightyears, LengthUnit.KilolightYear);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKilometers(QuantityValue kilometers)
+        public static Length FromKilometers(double kilometers)
         {
-            double value = (double) kilometers;
-            return new Length(value, LengthUnit.Kilometer);
+            return new Length(kilometers, LengthUnit.Kilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kiloparsec"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKiloparsecs(QuantityValue kiloparsecs)
+        public static Length FromKiloparsecs(double kiloparsecs)
         {
-            double value = (double) kiloparsecs;
-            return new Length(value, LengthUnit.Kiloparsec);
+            return new Length(kiloparsecs, LengthUnit.Kiloparsec);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kiloyard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKiloyards(QuantityValue kiloyards)
+        public static Length FromKiloyards(double kiloyards)
         {
-            double value = (double) kiloyards;
-            return new Length(value, LengthUnit.Kiloyard);
+            return new Length(kiloyards, LengthUnit.Kiloyard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.LightYear"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromLightYears(QuantityValue lightyears)
+        public static Length FromLightYears(double lightyears)
         {
-            double value = (double) lightyears;
-            return new Length(value, LengthUnit.LightYear);
+            return new Length(lightyears, LengthUnit.LightYear);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.MegalightYear"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMegalightYears(QuantityValue megalightyears)
+        public static Length FromMegalightYears(double megalightyears)
         {
-            double value = (double) megalightyears;
-            return new Length(value, LengthUnit.MegalightYear);
+            return new Length(megalightyears, LengthUnit.MegalightYear);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Megameter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMegameters(QuantityValue megameters)
+        public static Length FromMegameters(double megameters)
         {
-            double value = (double) megameters;
-            return new Length(value, LengthUnit.Megameter);
+            return new Length(megameters, LengthUnit.Megameter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Megaparsec"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMegaparsecs(QuantityValue megaparsecs)
+        public static Length FromMegaparsecs(double megaparsecs)
         {
-            double value = (double) megaparsecs;
-            return new Length(value, LengthUnit.Megaparsec);
+            return new Length(megaparsecs, LengthUnit.Megaparsec);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Meter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMeters(QuantityValue meters)
+        public static Length FromMeters(double meters)
         {
-            double value = (double) meters;
-            return new Length(value, LengthUnit.Meter);
+            return new Length(meters, LengthUnit.Meter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Microinch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMicroinches(QuantityValue microinches)
+        public static Length FromMicroinches(double microinches)
         {
-            double value = (double) microinches;
-            return new Length(value, LengthUnit.Microinch);
+            return new Length(microinches, LengthUnit.Microinch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Micrometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMicrometers(QuantityValue micrometers)
+        public static Length FromMicrometers(double micrometers)
         {
-            double value = (double) micrometers;
-            return new Length(value, LengthUnit.Micrometer);
+            return new Length(micrometers, LengthUnit.Micrometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Mil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMils(QuantityValue mils)
+        public static Length FromMils(double mils)
         {
-            double value = (double) mils;
-            return new Length(value, LengthUnit.Mil);
+            return new Length(mils, LengthUnit.Mil);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Mile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMiles(QuantityValue miles)
+        public static Length FromMiles(double miles)
         {
-            double value = (double) miles;
-            return new Length(value, LengthUnit.Mile);
+            return new Length(miles, LengthUnit.Mile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Millimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMillimeters(QuantityValue millimeters)
+        public static Length FromMillimeters(double millimeters)
         {
-            double value = (double) millimeters;
-            return new Length(value, LengthUnit.Millimeter);
+            return new Length(millimeters, LengthUnit.Millimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Nanometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromNanometers(QuantityValue nanometers)
+        public static Length FromNanometers(double nanometers)
         {
-            double value = (double) nanometers;
-            return new Length(value, LengthUnit.Nanometer);
+            return new Length(nanometers, LengthUnit.Nanometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.NauticalMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromNauticalMiles(QuantityValue nauticalmiles)
+        public static Length FromNauticalMiles(double nauticalmiles)
         {
-            double value = (double) nauticalmiles;
-            return new Length(value, LengthUnit.NauticalMile);
+            return new Length(nauticalmiles, LengthUnit.NauticalMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Parsec"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromParsecs(QuantityValue parsecs)
+        public static Length FromParsecs(double parsecs)
         {
-            double value = (double) parsecs;
-            return new Length(value, LengthUnit.Parsec);
+            return new Length(parsecs, LengthUnit.Parsec);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Picometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromPicometers(QuantityValue picometers)
+        public static Length FromPicometers(double picometers)
         {
-            double value = (double) picometers;
-            return new Length(value, LengthUnit.Picometer);
+            return new Length(picometers, LengthUnit.Picometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.PrinterPica"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromPrinterPicas(QuantityValue printerpicas)
+        public static Length FromPrinterPicas(double printerpicas)
         {
-            double value = (double) printerpicas;
-            return new Length(value, LengthUnit.PrinterPica);
+            return new Length(printerpicas, LengthUnit.PrinterPica);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.PrinterPoint"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromPrinterPoints(QuantityValue printerpoints)
+        public static Length FromPrinterPoints(double printerpoints)
         {
-            double value = (double) printerpoints;
-            return new Length(value, LengthUnit.PrinterPoint);
+            return new Length(printerpoints, LengthUnit.PrinterPoint);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Shackle"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromShackles(QuantityValue shackles)
+        public static Length FromShackles(double shackles)
         {
-            double value = (double) shackles;
-            return new Length(value, LengthUnit.Shackle);
+            return new Length(shackles, LengthUnit.Shackle);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.SolarRadius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromSolarRadiuses(QuantityValue solarradiuses)
+        public static Length FromSolarRadiuses(double solarradiuses)
         {
-            double value = (double) solarradiuses;
-            return new Length(value, LengthUnit.SolarRadius);
+            return new Length(solarradiuses, LengthUnit.SolarRadius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Twip"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromTwips(QuantityValue twips)
+        public static Length FromTwips(double twips)
         {
-            double value = (double) twips;
-            return new Length(value, LengthUnit.Twip);
+            return new Length(twips, LengthUnit.Twip);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.UsSurveyFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromUsSurveyFeet(QuantityValue ussurveyfeet)
+        public static Length FromUsSurveyFeet(double ussurveyfeet)
         {
-            double value = (double) ussurveyfeet;
-            return new Length(value, LengthUnit.UsSurveyFoot);
+            return new Length(ussurveyfeet, LengthUnit.UsSurveyFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Yard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromYards(QuantityValue yards)
+        public static Length FromYards(double yards)
         {
-            double value = (double) yards;
-            return new Length(value, LengthUnit.Yard);
+            return new Length(yards, LengthUnit.Yard);
         }
 
         /// <summary>
@@ -988,9 +946,9 @@ public static Length FromYards(QuantityValue yards)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Length unit value.</returns>
-        public static Length From(QuantityValue value, LengthUnit fromUnit)
+        public static Length From(double value, LengthUnit fromUnit)
         {
-            return new Length((double)value, fromUnit);
+            return new Length(value, fromUnit);
         }
 
         #endregion
@@ -1484,15 +1442,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LengthUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LengthUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LengthUnit)} is supported.", nameof(unit));
@@ -1689,18 +1638,6 @@ public Length ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LengthUnit> IQuantity<LengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Level.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
index a5400487bc..5343025e4f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Level.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Level :
-        IArithmeticQuantity<Level, LevelUnit, double>,
+        IArithmeticQuantity<Level, LevelUnit>,
         IComparable,
         IComparable<Level>,
         IConvertible,
@@ -148,7 +148,7 @@ public Level(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -229,20 +229,18 @@ public static string GetAbbreviation(LevelUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Level"/> from <see cref="LevelUnit.Decibel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Level FromDecibels(QuantityValue decibels)
+        public static Level FromDecibels(double decibels)
         {
-            double value = (double) decibels;
-            return new Level(value, LevelUnit.Decibel);
+            return new Level(decibels, LevelUnit.Decibel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Level"/> from <see cref="LevelUnit.Neper"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Level FromNepers(QuantityValue nepers)
+        public static Level FromNepers(double nepers)
         {
-            double value = (double) nepers;
-            return new Level(value, LevelUnit.Neper);
+            return new Level(nepers, LevelUnit.Neper);
         }
 
         /// <summary>
@@ -251,9 +249,9 @@ public static Level FromNepers(QuantityValue nepers)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Level unit value.</returns>
-        public static Level From(QuantityValue value, LevelUnit fromUnit)
+        public static Level From(double value, LevelUnit fromUnit)
         {
-            return new Level((double)value, fromUnit);
+            return new Level(value, fromUnit);
         }
 
         #endregion
@@ -437,14 +435,14 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Level
         public static Level operator *(Level left, double right)
         {
             // Logarithmic multiplication = addition
-            return new Level(left.Value + (double)right, left.Unit);
+            return new Level(left.Value + right, left.Unit);
         }
 
         /// <summary>Get <see cref="Level"/> from logarithmic division of <see cref="Level"/> by value.</summary>
         public static Level operator /(Level left, double right)
         {
             // Logarithmic division = subtraction
-            return new Level(left.Value - (double)right, left.Unit);
+            return new Level(left.Value - right, left.Unit);
         }
 
         /// <summary>Get ratio value from logarithmic division of <see cref="Level"/> by <see cref="Level"/>.</summary>
@@ -672,15 +670,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LevelUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LevelUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LevelUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LevelUnit)} is supported.", nameof(unit));
@@ -797,18 +786,6 @@ public Level ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LevelUnit> IQuantity<LevelUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LevelUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LevelUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
index 1066b2224a..d244dbf6d5 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct LinearDensity :
-        IArithmeticQuantity<LinearDensity, LinearDensityUnit, double>,
+        IArithmeticQuantity<LinearDensity, LinearDensityUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<LinearDensity, Density, Area>,
         IDivisionOperators<LinearDensity, Area, Density>,
@@ -171,7 +171,7 @@ public LinearDensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -336,140 +336,126 @@ public static string GetAbbreviation(LinearDensityUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerCentimeter(QuantityValue gramspercentimeter)
+        public static LinearDensity FromGramsPerCentimeter(double gramspercentimeter)
         {
-            double value = (double) gramspercentimeter;
-            return new LinearDensity(value, LinearDensityUnit.GramPerCentimeter);
+            return new LinearDensity(gramspercentimeter, LinearDensityUnit.GramPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerMeter(QuantityValue gramspermeter)
+        public static LinearDensity FromGramsPerMeter(double gramspermeter)
         {
-            double value = (double) gramspermeter;
-            return new LinearDensity(value, LinearDensityUnit.GramPerMeter);
+            return new LinearDensity(gramspermeter, LinearDensityUnit.GramPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerMillimeter(QuantityValue gramspermillimeter)
+        public static LinearDensity FromGramsPerMillimeter(double gramspermillimeter)
         {
-            double value = (double) gramspermillimeter;
-            return new LinearDensity(value, LinearDensityUnit.GramPerMillimeter);
+            return new LinearDensity(gramspermillimeter, LinearDensityUnit.GramPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerCentimeter(QuantityValue kilogramspercentimeter)
+        public static LinearDensity FromKilogramsPerCentimeter(double kilogramspercentimeter)
         {
-            double value = (double) kilogramspercentimeter;
-            return new LinearDensity(value, LinearDensityUnit.KilogramPerCentimeter);
+            return new LinearDensity(kilogramspercentimeter, LinearDensityUnit.KilogramPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerMeter(QuantityValue kilogramspermeter)
+        public static LinearDensity FromKilogramsPerMeter(double kilogramspermeter)
         {
-            double value = (double) kilogramspermeter;
-            return new LinearDensity(value, LinearDensityUnit.KilogramPerMeter);
+            return new LinearDensity(kilogramspermeter, LinearDensityUnit.KilogramPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerMillimeter(QuantityValue kilogramspermillimeter)
+        public static LinearDensity FromKilogramsPerMillimeter(double kilogramspermillimeter)
         {
-            double value = (double) kilogramspermillimeter;
-            return new LinearDensity(value, LinearDensityUnit.KilogramPerMillimeter);
+            return new LinearDensity(kilogramspermillimeter, LinearDensityUnit.KilogramPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerCentimeter(QuantityValue microgramspercentimeter)
+        public static LinearDensity FromMicrogramsPerCentimeter(double microgramspercentimeter)
         {
-            double value = (double) microgramspercentimeter;
-            return new LinearDensity(value, LinearDensityUnit.MicrogramPerCentimeter);
+            return new LinearDensity(microgramspercentimeter, LinearDensityUnit.MicrogramPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerMeter(QuantityValue microgramspermeter)
+        public static LinearDensity FromMicrogramsPerMeter(double microgramspermeter)
         {
-            double value = (double) microgramspermeter;
-            return new LinearDensity(value, LinearDensityUnit.MicrogramPerMeter);
+            return new LinearDensity(microgramspermeter, LinearDensityUnit.MicrogramPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerMillimeter(QuantityValue microgramspermillimeter)
+        public static LinearDensity FromMicrogramsPerMillimeter(double microgramspermillimeter)
         {
-            double value = (double) microgramspermillimeter;
-            return new LinearDensity(value, LinearDensityUnit.MicrogramPerMillimeter);
+            return new LinearDensity(microgramspermillimeter, LinearDensityUnit.MicrogramPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerCentimeter(QuantityValue milligramspercentimeter)
+        public static LinearDensity FromMilligramsPerCentimeter(double milligramspercentimeter)
         {
-            double value = (double) milligramspercentimeter;
-            return new LinearDensity(value, LinearDensityUnit.MilligramPerCentimeter);
+            return new LinearDensity(milligramspercentimeter, LinearDensityUnit.MilligramPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerMeter(QuantityValue milligramspermeter)
+        public static LinearDensity FromMilligramsPerMeter(double milligramspermeter)
         {
-            double value = (double) milligramspermeter;
-            return new LinearDensity(value, LinearDensityUnit.MilligramPerMeter);
+            return new LinearDensity(milligramspermeter, LinearDensityUnit.MilligramPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerMillimeter(QuantityValue milligramspermillimeter)
+        public static LinearDensity FromMilligramsPerMillimeter(double milligramspermillimeter)
         {
-            double value = (double) milligramspermillimeter;
-            return new LinearDensity(value, LinearDensityUnit.MilligramPerMillimeter);
+            return new LinearDensity(milligramspermillimeter, LinearDensityUnit.MilligramPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.PoundPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromPoundsPerFoot(QuantityValue poundsperfoot)
+        public static LinearDensity FromPoundsPerFoot(double poundsperfoot)
         {
-            double value = (double) poundsperfoot;
-            return new LinearDensity(value, LinearDensityUnit.PoundPerFoot);
+            return new LinearDensity(poundsperfoot, LinearDensityUnit.PoundPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.PoundPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromPoundsPerInch(QuantityValue poundsperinch)
+        public static LinearDensity FromPoundsPerInch(double poundsperinch)
         {
-            double value = (double) poundsperinch;
-            return new LinearDensity(value, LinearDensityUnit.PoundPerInch);
+            return new LinearDensity(poundsperinch, LinearDensityUnit.PoundPerInch);
         }
 
         /// <summary>
@@ -478,9 +464,9 @@ public static LinearDensity FromPoundsPerInch(QuantityValue poundsperinch)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LinearDensity unit value.</returns>
-        public static LinearDensity From(QuantityValue value, LinearDensityUnit fromUnit)
+        public static LinearDensity From(double value, LinearDensityUnit fromUnit)
         {
-            return new LinearDensity((double)value, fromUnit);
+            return new LinearDensity(value, fromUnit);
         }
 
         #endregion
@@ -913,15 +899,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LinearDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearDensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LinearDensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearDensityUnit)} is supported.", nameof(unit));
@@ -1062,18 +1039,6 @@ public LinearDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LinearDensityUnit> IQuantity<LinearDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LinearDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
index 9cffb201d4..900302a53e 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct LinearPowerDensity :
-        IArithmeticQuantity<LinearPowerDensity, LinearPowerDensityUnit, double>,
+        IArithmeticQuantity<LinearPowerDensity, LinearPowerDensityUnit>,
         IComparable,
         IComparable<LinearPowerDensity>,
         IConvertible,
@@ -174,7 +174,7 @@ public LinearPowerDensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -416,250 +416,225 @@ public static string GetAbbreviation(LinearPowerDensityUnit unit, IFormatProvide
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerCentimeter(QuantityValue gigawattspercentimeter)
+        public static LinearPowerDensity FromGigawattsPerCentimeter(double gigawattspercentimeter)
         {
-            double value = (double) gigawattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter);
+            return new LinearPowerDensity(gigawattspercentimeter, LinearPowerDensityUnit.GigawattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerFoot(QuantityValue gigawattsperfoot)
+        public static LinearPowerDensity FromGigawattsPerFoot(double gigawattsperfoot)
         {
-            double value = (double) gigawattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot);
+            return new LinearPowerDensity(gigawattsperfoot, LinearPowerDensityUnit.GigawattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerInch(QuantityValue gigawattsperinch)
+        public static LinearPowerDensity FromGigawattsPerInch(double gigawattsperinch)
         {
-            double value = (double) gigawattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch);
+            return new LinearPowerDensity(gigawattsperinch, LinearPowerDensityUnit.GigawattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerMeter(QuantityValue gigawattspermeter)
+        public static LinearPowerDensity FromGigawattsPerMeter(double gigawattspermeter)
         {
-            double value = (double) gigawattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter);
+            return new LinearPowerDensity(gigawattspermeter, LinearPowerDensityUnit.GigawattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerMillimeter(QuantityValue gigawattspermillimeter)
+        public static LinearPowerDensity FromGigawattsPerMillimeter(double gigawattspermillimeter)
         {
-            double value = (double) gigawattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter);
+            return new LinearPowerDensity(gigawattspermillimeter, LinearPowerDensityUnit.GigawattPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerCentimeter(QuantityValue kilowattspercentimeter)
+        public static LinearPowerDensity FromKilowattsPerCentimeter(double kilowattspercentimeter)
         {
-            double value = (double) kilowattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter);
+            return new LinearPowerDensity(kilowattspercentimeter, LinearPowerDensityUnit.KilowattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerFoot(QuantityValue kilowattsperfoot)
+        public static LinearPowerDensity FromKilowattsPerFoot(double kilowattsperfoot)
         {
-            double value = (double) kilowattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot);
+            return new LinearPowerDensity(kilowattsperfoot, LinearPowerDensityUnit.KilowattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerInch(QuantityValue kilowattsperinch)
+        public static LinearPowerDensity FromKilowattsPerInch(double kilowattsperinch)
         {
-            double value = (double) kilowattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch);
+            return new LinearPowerDensity(kilowattsperinch, LinearPowerDensityUnit.KilowattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerMeter(QuantityValue kilowattspermeter)
+        public static LinearPowerDensity FromKilowattsPerMeter(double kilowattspermeter)
         {
-            double value = (double) kilowattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter);
+            return new LinearPowerDensity(kilowattspermeter, LinearPowerDensityUnit.KilowattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerMillimeter(QuantityValue kilowattspermillimeter)
+        public static LinearPowerDensity FromKilowattsPerMillimeter(double kilowattspermillimeter)
         {
-            double value = (double) kilowattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter);
+            return new LinearPowerDensity(kilowattspermillimeter, LinearPowerDensityUnit.KilowattPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerCentimeter(QuantityValue megawattspercentimeter)
+        public static LinearPowerDensity FromMegawattsPerCentimeter(double megawattspercentimeter)
         {
-            double value = (double) megawattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter);
+            return new LinearPowerDensity(megawattspercentimeter, LinearPowerDensityUnit.MegawattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerFoot(QuantityValue megawattsperfoot)
+        public static LinearPowerDensity FromMegawattsPerFoot(double megawattsperfoot)
         {
-            double value = (double) megawattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot);
+            return new LinearPowerDensity(megawattsperfoot, LinearPowerDensityUnit.MegawattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerInch(QuantityValue megawattsperinch)
+        public static LinearPowerDensity FromMegawattsPerInch(double megawattsperinch)
         {
-            double value = (double) megawattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch);
+            return new LinearPowerDensity(megawattsperinch, LinearPowerDensityUnit.MegawattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerMeter(QuantityValue megawattspermeter)
+        public static LinearPowerDensity FromMegawattsPerMeter(double megawattspermeter)
         {
-            double value = (double) megawattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter);
+            return new LinearPowerDensity(megawattspermeter, LinearPowerDensityUnit.MegawattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerMillimeter(QuantityValue megawattspermillimeter)
+        public static LinearPowerDensity FromMegawattsPerMillimeter(double megawattspermillimeter)
         {
-            double value = (double) megawattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter);
+            return new LinearPowerDensity(megawattspermillimeter, LinearPowerDensityUnit.MegawattPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerCentimeter(QuantityValue milliwattspercentimeter)
+        public static LinearPowerDensity FromMilliwattsPerCentimeter(double milliwattspercentimeter)
         {
-            double value = (double) milliwattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter);
+            return new LinearPowerDensity(milliwattspercentimeter, LinearPowerDensityUnit.MilliwattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerFoot(QuantityValue milliwattsperfoot)
+        public static LinearPowerDensity FromMilliwattsPerFoot(double milliwattsperfoot)
         {
-            double value = (double) milliwattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot);
+            return new LinearPowerDensity(milliwattsperfoot, LinearPowerDensityUnit.MilliwattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerInch(QuantityValue milliwattsperinch)
+        public static LinearPowerDensity FromMilliwattsPerInch(double milliwattsperinch)
         {
-            double value = (double) milliwattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch);
+            return new LinearPowerDensity(milliwattsperinch, LinearPowerDensityUnit.MilliwattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerMeter(QuantityValue milliwattspermeter)
+        public static LinearPowerDensity FromMilliwattsPerMeter(double milliwattspermeter)
         {
-            double value = (double) milliwattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter);
+            return new LinearPowerDensity(milliwattspermeter, LinearPowerDensityUnit.MilliwattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerMillimeter(QuantityValue milliwattspermillimeter)
+        public static LinearPowerDensity FromMilliwattsPerMillimeter(double milliwattspermillimeter)
         {
-            double value = (double) milliwattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter);
+            return new LinearPowerDensity(milliwattspermillimeter, LinearPowerDensityUnit.MilliwattPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerCentimeter(QuantityValue wattspercentimeter)
+        public static LinearPowerDensity FromWattsPerCentimeter(double wattspercentimeter)
         {
-            double value = (double) wattspercentimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter);
+            return new LinearPowerDensity(wattspercentimeter, LinearPowerDensityUnit.WattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerFoot(QuantityValue wattsperfoot)
+        public static LinearPowerDensity FromWattsPerFoot(double wattsperfoot)
         {
-            double value = (double) wattsperfoot;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot);
+            return new LinearPowerDensity(wattsperfoot, LinearPowerDensityUnit.WattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerInch(QuantityValue wattsperinch)
+        public static LinearPowerDensity FromWattsPerInch(double wattsperinch)
         {
-            double value = (double) wattsperinch;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch);
+            return new LinearPowerDensity(wattsperinch, LinearPowerDensityUnit.WattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerMeter(QuantityValue wattspermeter)
+        public static LinearPowerDensity FromWattsPerMeter(double wattspermeter)
         {
-            double value = (double) wattspermeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter);
+            return new LinearPowerDensity(wattspermeter, LinearPowerDensityUnit.WattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerMillimeter(QuantityValue wattspermillimeter)
+        public static LinearPowerDensity FromWattsPerMillimeter(double wattspermillimeter)
         {
-            double value = (double) wattspermillimeter;
-            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter);
+            return new LinearPowerDensity(wattspermillimeter, LinearPowerDensityUnit.WattPerMillimeter);
         }
 
         /// <summary>
@@ -668,9 +643,9 @@ public static LinearPowerDensity FromWattsPerMillimeter(QuantityValue wattspermi
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LinearPowerDensity unit value.</returns>
-        public static LinearPowerDensity From(QuantityValue value, LinearPowerDensityUnit fromUnit)
+        public static LinearPowerDensity From(double value, LinearPowerDensityUnit fromUnit)
         {
-            return new LinearPowerDensity((double)value, fromUnit);
+            return new LinearPowerDensity(value, fromUnit);
         }
 
         #endregion
@@ -1081,15 +1056,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LinearPowerDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearPowerDensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LinearPowerDensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearPowerDensityUnit)} is supported.", nameof(unit));
@@ -1252,18 +1218,6 @@ public LinearPowerDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LinearPowerDensityUnit> IQuantity<LinearPowerDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LinearPowerDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LinearPowerDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
index 883435684d..c7f77fe15a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Luminance :
-        IArithmeticQuantity<Luminance, LuminanceUnit, double>,
+        IArithmeticQuantity<Luminance, LuminanceUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Luminance, Area, LuminousIntensity>,
 #endif
@@ -165,7 +165,7 @@ public Luminance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -302,100 +302,90 @@ public static string GetAbbreviation(LuminanceUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromCandelasPerSquareFoot(QuantityValue candelaspersquarefoot)
+        public static Luminance FromCandelasPerSquareFoot(double candelaspersquarefoot)
         {
-            double value = (double) candelaspersquarefoot;
-            return new Luminance(value, LuminanceUnit.CandelaPerSquareFoot);
+            return new Luminance(candelaspersquarefoot, LuminanceUnit.CandelaPerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromCandelasPerSquareInch(QuantityValue candelaspersquareinch)
+        public static Luminance FromCandelasPerSquareInch(double candelaspersquareinch)
         {
-            double value = (double) candelaspersquareinch;
-            return new Luminance(value, LuminanceUnit.CandelaPerSquareInch);
+            return new Luminance(candelaspersquareinch, LuminanceUnit.CandelaPerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromCandelasPerSquareMeter(QuantityValue candelaspersquaremeter)
+        public static Luminance FromCandelasPerSquareMeter(double candelaspersquaremeter)
         {
-            double value = (double) candelaspersquaremeter;
-            return new Luminance(value, LuminanceUnit.CandelaPerSquareMeter);
+            return new Luminance(candelaspersquaremeter, LuminanceUnit.CandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CenticandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromCenticandelasPerSquareMeter(QuantityValue centicandelaspersquaremeter)
+        public static Luminance FromCenticandelasPerSquareMeter(double centicandelaspersquaremeter)
         {
-            double value = (double) centicandelaspersquaremeter;
-            return new Luminance(value, LuminanceUnit.CenticandelaPerSquareMeter);
+            return new Luminance(centicandelaspersquaremeter, LuminanceUnit.CenticandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.DecicandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromDecicandelasPerSquareMeter(QuantityValue decicandelaspersquaremeter)
+        public static Luminance FromDecicandelasPerSquareMeter(double decicandelaspersquaremeter)
         {
-            double value = (double) decicandelaspersquaremeter;
-            return new Luminance(value, LuminanceUnit.DecicandelaPerSquareMeter);
+            return new Luminance(decicandelaspersquaremeter, LuminanceUnit.DecicandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.KilocandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromKilocandelasPerSquareMeter(QuantityValue kilocandelaspersquaremeter)
+        public static Luminance FromKilocandelasPerSquareMeter(double kilocandelaspersquaremeter)
         {
-            double value = (double) kilocandelaspersquaremeter;
-            return new Luminance(value, LuminanceUnit.KilocandelaPerSquareMeter);
+            return new Luminance(kilocandelaspersquaremeter, LuminanceUnit.KilocandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.MicrocandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromMicrocandelasPerSquareMeter(QuantityValue microcandelaspersquaremeter)
+        public static Luminance FromMicrocandelasPerSquareMeter(double microcandelaspersquaremeter)
         {
-            double value = (double) microcandelaspersquaremeter;
-            return new Luminance(value, LuminanceUnit.MicrocandelaPerSquareMeter);
+            return new Luminance(microcandelaspersquaremeter, LuminanceUnit.MicrocandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.MillicandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromMillicandelasPerSquareMeter(QuantityValue millicandelaspersquaremeter)
+        public static Luminance FromMillicandelasPerSquareMeter(double millicandelaspersquaremeter)
         {
-            double value = (double) millicandelaspersquaremeter;
-            return new Luminance(value, LuminanceUnit.MillicandelaPerSquareMeter);
+            return new Luminance(millicandelaspersquaremeter, LuminanceUnit.MillicandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.NanocandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromNanocandelasPerSquareMeter(QuantityValue nanocandelaspersquaremeter)
+        public static Luminance FromNanocandelasPerSquareMeter(double nanocandelaspersquaremeter)
         {
-            double value = (double) nanocandelaspersquaremeter;
-            return new Luminance(value, LuminanceUnit.NanocandelaPerSquareMeter);
+            return new Luminance(nanocandelaspersquaremeter, LuminanceUnit.NanocandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.Nit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromNits(QuantityValue nits)
+        public static Luminance FromNits(double nits)
         {
-            double value = (double) nits;
-            return new Luminance(value, LuminanceUnit.Nit);
+            return new Luminance(nits, LuminanceUnit.Nit);
         }
 
         /// <summary>
@@ -404,9 +394,9 @@ public static Luminance FromNits(QuantityValue nits)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Luminance unit value.</returns>
-        public static Luminance From(QuantityValue value, LuminanceUnit fromUnit)
+        public static Luminance From(double value, LuminanceUnit fromUnit)
         {
-            return new Luminance((double)value, fromUnit);
+            return new Luminance(value, fromUnit);
         }
 
         #endregion
@@ -827,15 +817,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LuminanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LuminanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminanceUnit)} is supported.", nameof(unit));
@@ -968,18 +949,6 @@ public Luminance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LuminanceUnit> IQuantity<LuminanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LuminanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
index 1c9ecef869..0df8fb7e24 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Luminosity :
-        IArithmeticQuantity<Luminosity, LuminosityUnit, double>,
+        IArithmeticQuantity<Luminosity, LuminosityUnit>,
         IComparable,
         IComparable<Luminosity>,
         IConvertible,
@@ -163,7 +163,7 @@ public Luminosity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -328,140 +328,126 @@ public static string GetAbbreviation(LuminosityUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Decawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromDecawatts(QuantityValue decawatts)
+        public static Luminosity FromDecawatts(double decawatts)
         {
-            double value = (double) decawatts;
-            return new Luminosity(value, LuminosityUnit.Decawatt);
+            return new Luminosity(decawatts, LuminosityUnit.Decawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Deciwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromDeciwatts(QuantityValue deciwatts)
+        public static Luminosity FromDeciwatts(double deciwatts)
         {
-            double value = (double) deciwatts;
-            return new Luminosity(value, LuminosityUnit.Deciwatt);
+            return new Luminosity(deciwatts, LuminosityUnit.Deciwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Femtowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromFemtowatts(QuantityValue femtowatts)
+        public static Luminosity FromFemtowatts(double femtowatts)
         {
-            double value = (double) femtowatts;
-            return new Luminosity(value, LuminosityUnit.Femtowatt);
+            return new Luminosity(femtowatts, LuminosityUnit.Femtowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Gigawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromGigawatts(QuantityValue gigawatts)
+        public static Luminosity FromGigawatts(double gigawatts)
         {
-            double value = (double) gigawatts;
-            return new Luminosity(value, LuminosityUnit.Gigawatt);
+            return new Luminosity(gigawatts, LuminosityUnit.Gigawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Kilowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromKilowatts(QuantityValue kilowatts)
+        public static Luminosity FromKilowatts(double kilowatts)
         {
-            double value = (double) kilowatts;
-            return new Luminosity(value, LuminosityUnit.Kilowatt);
+            return new Luminosity(kilowatts, LuminosityUnit.Kilowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Megawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMegawatts(QuantityValue megawatts)
+        public static Luminosity FromMegawatts(double megawatts)
         {
-            double value = (double) megawatts;
-            return new Luminosity(value, LuminosityUnit.Megawatt);
+            return new Luminosity(megawatts, LuminosityUnit.Megawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Microwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMicrowatts(QuantityValue microwatts)
+        public static Luminosity FromMicrowatts(double microwatts)
         {
-            double value = (double) microwatts;
-            return new Luminosity(value, LuminosityUnit.Microwatt);
+            return new Luminosity(microwatts, LuminosityUnit.Microwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Milliwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMilliwatts(QuantityValue milliwatts)
+        public static Luminosity FromMilliwatts(double milliwatts)
         {
-            double value = (double) milliwatts;
-            return new Luminosity(value, LuminosityUnit.Milliwatt);
+            return new Luminosity(milliwatts, LuminosityUnit.Milliwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Nanowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromNanowatts(QuantityValue nanowatts)
+        public static Luminosity FromNanowatts(double nanowatts)
         {
-            double value = (double) nanowatts;
-            return new Luminosity(value, LuminosityUnit.Nanowatt);
+            return new Luminosity(nanowatts, LuminosityUnit.Nanowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Petawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromPetawatts(QuantityValue petawatts)
+        public static Luminosity FromPetawatts(double petawatts)
         {
-            double value = (double) petawatts;
-            return new Luminosity(value, LuminosityUnit.Petawatt);
+            return new Luminosity(petawatts, LuminosityUnit.Petawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Picowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromPicowatts(QuantityValue picowatts)
+        public static Luminosity FromPicowatts(double picowatts)
         {
-            double value = (double) picowatts;
-            return new Luminosity(value, LuminosityUnit.Picowatt);
+            return new Luminosity(picowatts, LuminosityUnit.Picowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.SolarLuminosity"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromSolarLuminosities(QuantityValue solarluminosities)
+        public static Luminosity FromSolarLuminosities(double solarluminosities)
         {
-            double value = (double) solarluminosities;
-            return new Luminosity(value, LuminosityUnit.SolarLuminosity);
+            return new Luminosity(solarluminosities, LuminosityUnit.SolarLuminosity);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Terawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromTerawatts(QuantityValue terawatts)
+        public static Luminosity FromTerawatts(double terawatts)
         {
-            double value = (double) terawatts;
-            return new Luminosity(value, LuminosityUnit.Terawatt);
+            return new Luminosity(terawatts, LuminosityUnit.Terawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Watt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromWatts(QuantityValue watts)
+        public static Luminosity FromWatts(double watts)
         {
-            double value = (double) watts;
-            return new Luminosity(value, LuminosityUnit.Watt);
+            return new Luminosity(watts, LuminosityUnit.Watt);
         }
 
         /// <summary>
@@ -470,9 +456,9 @@ public static Luminosity FromWatts(QuantityValue watts)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Luminosity unit value.</returns>
-        public static Luminosity From(QuantityValue value, LuminosityUnit fromUnit)
+        public static Luminosity From(double value, LuminosityUnit fromUnit)
         {
-            return new Luminosity((double)value, fromUnit);
+            return new Luminosity(value, fromUnit);
         }
 
         #endregion
@@ -883,15 +869,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LuminosityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminosityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LuminosityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminosityUnit)} is supported.", nameof(unit));
@@ -1032,18 +1009,6 @@ public Luminosity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LuminosityUnit> IQuantity<LuminosityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LuminosityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminosityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
index 6bfccfe0c6..785e2c1a02 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct LuminousFlux :
-        IArithmeticQuantity<LuminousFlux, LuminousFluxUnit, double>,
+        IArithmeticQuantity<LuminousFlux, LuminousFluxUnit>,
         IComparable,
         IComparable<LuminousFlux>,
         IConvertible,
@@ -150,7 +150,7 @@ public LuminousFlux(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(LuminousFluxUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="LuminousFlux"/> from <see cref="LuminousFluxUnit.Lumen"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LuminousFlux FromLumens(QuantityValue lumens)
+        public static LuminousFlux FromLumens(double lumens)
         {
-            double value = (double) lumens;
-            return new LuminousFlux(value, LuminousFluxUnit.Lumen);
+            return new LuminousFlux(lumens, LuminousFluxUnit.Lumen);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static LuminousFlux FromLumens(QuantityValue lumens)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LuminousFlux unit value.</returns>
-        public static LuminousFlux From(QuantityValue value, LuminousFluxUnit fromUnit)
+        public static LuminousFlux From(double value, LuminousFluxUnit fromUnit)
         {
-            return new LuminousFlux((double)value, fromUnit);
+            return new LuminousFlux(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LuminousFluxUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousFluxUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LuminousFluxUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousFluxUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public LuminousFlux ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LuminousFluxUnit> IQuantity<LuminousFluxUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LuminousFluxUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousFluxUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
index dc3aa573f6..43d4a65664 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct LuminousIntensity :
-        IArithmeticQuantity<LuminousIntensity, LuminousIntensityUnit, double>,
+        IArithmeticQuantity<LuminousIntensity, LuminousIntensityUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<LuminousIntensity, Luminance, Area>,
         IDivisionOperators<LuminousIntensity, Area, Luminance>,
@@ -157,7 +157,7 @@ public LuminousIntensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -231,10 +231,9 @@ public static string GetAbbreviation(LuminousIntensityUnit unit, IFormatProvider
         ///     Creates a <see cref="LuminousIntensity"/> from <see cref="LuminousIntensityUnit.Candela"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LuminousIntensity FromCandela(QuantityValue candela)
+        public static LuminousIntensity FromCandela(double candela)
         {
-            double value = (double) candela;
-            return new LuminousIntensity(value, LuminousIntensityUnit.Candela);
+            return new LuminousIntensity(candela, LuminousIntensityUnit.Candela);
         }
 
         /// <summary>
@@ -243,9 +242,9 @@ public static LuminousIntensity FromCandela(QuantityValue candela)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>LuminousIntensity unit value.</returns>
-        public static LuminousIntensity From(QuantityValue value, LuminousIntensityUnit fromUnit)
+        public static LuminousIntensity From(double value, LuminousIntensityUnit fromUnit)
         {
-            return new LuminousIntensity((double)value, fromUnit);
+            return new LuminousIntensity(value, fromUnit);
         }
 
         #endregion
@@ -672,15 +671,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is LuminousIntensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousIntensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is LuminousIntensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousIntensityUnit)} is supported.", nameof(unit));
@@ -795,18 +785,6 @@ public LuminousIntensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<LuminousIntensityUnit> IQuantity<LuminousIntensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not LuminousIntensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(LuminousIntensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
index ae039d94fc..583f0dcbd5 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct MagneticField :
-        IArithmeticQuantity<MagneticField, MagneticFieldUnit, double>,
+        IArithmeticQuantity<MagneticField, MagneticFieldUnit>,
         IComparable,
         IComparable<MagneticField>,
         IConvertible,
@@ -155,7 +155,7 @@ public MagneticField(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -264,60 +264,54 @@ public static string GetAbbreviation(MagneticFieldUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Gauss"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromGausses(QuantityValue gausses)
+        public static MagneticField FromGausses(double gausses)
         {
-            double value = (double) gausses;
-            return new MagneticField(value, MagneticFieldUnit.Gauss);
+            return new MagneticField(gausses, MagneticFieldUnit.Gauss);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Microtesla"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromMicroteslas(QuantityValue microteslas)
+        public static MagneticField FromMicroteslas(double microteslas)
         {
-            double value = (double) microteslas;
-            return new MagneticField(value, MagneticFieldUnit.Microtesla);
+            return new MagneticField(microteslas, MagneticFieldUnit.Microtesla);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Milligauss"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromMilligausses(QuantityValue milligausses)
+        public static MagneticField FromMilligausses(double milligausses)
         {
-            double value = (double) milligausses;
-            return new MagneticField(value, MagneticFieldUnit.Milligauss);
+            return new MagneticField(milligausses, MagneticFieldUnit.Milligauss);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Millitesla"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromMilliteslas(QuantityValue milliteslas)
+        public static MagneticField FromMilliteslas(double milliteslas)
         {
-            double value = (double) milliteslas;
-            return new MagneticField(value, MagneticFieldUnit.Millitesla);
+            return new MagneticField(milliteslas, MagneticFieldUnit.Millitesla);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Nanotesla"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromNanoteslas(QuantityValue nanoteslas)
+        public static MagneticField FromNanoteslas(double nanoteslas)
         {
-            double value = (double) nanoteslas;
-            return new MagneticField(value, MagneticFieldUnit.Nanotesla);
+            return new MagneticField(nanoteslas, MagneticFieldUnit.Nanotesla);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Tesla"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromTeslas(QuantityValue teslas)
+        public static MagneticField FromTeslas(double teslas)
         {
-            double value = (double) teslas;
-            return new MagneticField(value, MagneticFieldUnit.Tesla);
+            return new MagneticField(teslas, MagneticFieldUnit.Tesla);
         }
 
         /// <summary>
@@ -326,9 +320,9 @@ public static MagneticField FromTeslas(QuantityValue teslas)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MagneticField unit value.</returns>
-        public static MagneticField From(QuantityValue value, MagneticFieldUnit fromUnit)
+        public static MagneticField From(double value, MagneticFieldUnit fromUnit)
         {
-            return new MagneticField((double)value, fromUnit);
+            return new MagneticField(value, fromUnit);
         }
 
         #endregion
@@ -739,15 +733,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MagneticFieldUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFieldUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MagneticFieldUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFieldUnit)} is supported.", nameof(unit));
@@ -872,18 +857,6 @@ public MagneticField ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MagneticFieldUnit> IQuantity<MagneticFieldUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MagneticFieldUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFieldUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
index 50b4d387c8..15465cb859 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct MagneticFlux :
-        IArithmeticQuantity<MagneticFlux, MagneticFluxUnit, double>,
+        IArithmeticQuantity<MagneticFlux, MagneticFluxUnit>,
         IComparable,
         IComparable<MagneticFlux>,
         IConvertible,
@@ -150,7 +150,7 @@ public MagneticFlux(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(MagneticFluxUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="MagneticFlux"/> from <see cref="MagneticFluxUnit.Weber"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticFlux FromWebers(QuantityValue webers)
+        public static MagneticFlux FromWebers(double webers)
         {
-            double value = (double) webers;
-            return new MagneticFlux(value, MagneticFluxUnit.Weber);
+            return new MagneticFlux(webers, MagneticFluxUnit.Weber);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static MagneticFlux FromWebers(QuantityValue webers)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MagneticFlux unit value.</returns>
-        public static MagneticFlux From(QuantityValue value, MagneticFluxUnit fromUnit)
+        public static MagneticFlux From(double value, MagneticFluxUnit fromUnit)
         {
-            return new MagneticFlux((double)value, fromUnit);
+            return new MagneticFlux(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MagneticFluxUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFluxUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MagneticFluxUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFluxUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public MagneticFlux ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MagneticFluxUnit> IQuantity<MagneticFluxUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MagneticFluxUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagneticFluxUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
index cadecb3367..df422b1ca0 100644
--- a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Magnetization :
-        IArithmeticQuantity<Magnetization, MagnetizationUnit, double>,
+        IArithmeticQuantity<Magnetization, MagnetizationUnit>,
         IComparable,
         IComparable<Magnetization>,
         IConvertible,
@@ -150,7 +150,7 @@ public Magnetization(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(MagnetizationUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="Magnetization"/> from <see cref="MagnetizationUnit.AmperePerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Magnetization FromAmperesPerMeter(QuantityValue amperespermeter)
+        public static Magnetization FromAmperesPerMeter(double amperespermeter)
         {
-            double value = (double) amperespermeter;
-            return new Magnetization(value, MagnetizationUnit.AmperePerMeter);
+            return new Magnetization(amperespermeter, MagnetizationUnit.AmperePerMeter);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static Magnetization FromAmperesPerMeter(QuantityValue amperespermeter)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Magnetization unit value.</returns>
-        public static Magnetization From(QuantityValue value, MagnetizationUnit fromUnit)
+        public static Magnetization From(double value, MagnetizationUnit fromUnit)
         {
-            return new Magnetization((double)value, fromUnit);
+            return new Magnetization(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MagnetizationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagnetizationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MagnetizationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagnetizationUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public Magnetization ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MagnetizationUnit> IQuantity<MagnetizationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MagnetizationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MagnetizationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
index 1ff055bda1..1d5da4b22d 100644
--- a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Mass :
-        IArithmeticQuantity<Mass, MassUnit, double>,
+        IArithmeticQuantity<Mass, MassUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Mass, MolarMass, AmountOfSubstance>,
         IDivisionOperators<Mass, AreaDensity, Area>,
@@ -193,7 +193,7 @@ public Mass(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -449,270 +449,243 @@ public static string GetAbbreviation(MassUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Centigram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromCentigrams(QuantityValue centigrams)
+        public static Mass FromCentigrams(double centigrams)
         {
-            double value = (double) centigrams;
-            return new Mass(value, MassUnit.Centigram);
+            return new Mass(centigrams, MassUnit.Centigram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Decagram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromDecagrams(QuantityValue decagrams)
+        public static Mass FromDecagrams(double decagrams)
         {
-            double value = (double) decagrams;
-            return new Mass(value, MassUnit.Decagram);
+            return new Mass(decagrams, MassUnit.Decagram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Decigram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromDecigrams(QuantityValue decigrams)
+        public static Mass FromDecigrams(double decigrams)
         {
-            double value = (double) decigrams;
-            return new Mass(value, MassUnit.Decigram);
+            return new Mass(decigrams, MassUnit.Decigram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.EarthMass"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromEarthMasses(QuantityValue earthmasses)
+        public static Mass FromEarthMasses(double earthmasses)
         {
-            double value = (double) earthmasses;
-            return new Mass(value, MassUnit.EarthMass);
+            return new Mass(earthmasses, MassUnit.EarthMass);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Femtogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromFemtograms(QuantityValue femtograms)
+        public static Mass FromFemtograms(double femtograms)
         {
-            double value = (double) femtograms;
-            return new Mass(value, MassUnit.Femtogram);
+            return new Mass(femtograms, MassUnit.Femtogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Grain"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromGrains(QuantityValue grains)
+        public static Mass FromGrains(double grains)
         {
-            double value = (double) grains;
-            return new Mass(value, MassUnit.Grain);
+            return new Mass(grains, MassUnit.Grain);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Gram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromGrams(QuantityValue grams)
+        public static Mass FromGrams(double grams)
         {
-            double value = (double) grams;
-            return new Mass(value, MassUnit.Gram);
+            return new Mass(grams, MassUnit.Gram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Hectogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromHectograms(QuantityValue hectograms)
+        public static Mass FromHectograms(double hectograms)
         {
-            double value = (double) hectograms;
-            return new Mass(value, MassUnit.Hectogram);
+            return new Mass(hectograms, MassUnit.Hectogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilograms(QuantityValue kilograms)
+        public static Mass FromKilograms(double kilograms)
         {
-            double value = (double) kilograms;
-            return new Mass(value, MassUnit.Kilogram);
+            return new Mass(kilograms, MassUnit.Kilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilopound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilopounds(QuantityValue kilopounds)
+        public static Mass FromKilopounds(double kilopounds)
         {
-            double value = (double) kilopounds;
-            return new Mass(value, MassUnit.Kilopound);
+            return new Mass(kilopounds, MassUnit.Kilopound);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilotonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilotonnes(QuantityValue kilotonnes)
+        public static Mass FromKilotonnes(double kilotonnes)
         {
-            double value = (double) kilotonnes;
-            return new Mass(value, MassUnit.Kilotonne);
+            return new Mass(kilotonnes, MassUnit.Kilotonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.LongHundredweight"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromLongHundredweight(QuantityValue longhundredweight)
+        public static Mass FromLongHundredweight(double longhundredweight)
         {
-            double value = (double) longhundredweight;
-            return new Mass(value, MassUnit.LongHundredweight);
+            return new Mass(longhundredweight, MassUnit.LongHundredweight);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.LongTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromLongTons(QuantityValue longtons)
+        public static Mass FromLongTons(double longtons)
         {
-            double value = (double) longtons;
-            return new Mass(value, MassUnit.LongTon);
+            return new Mass(longtons, MassUnit.LongTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megapound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMegapounds(QuantityValue megapounds)
+        public static Mass FromMegapounds(double megapounds)
         {
-            double value = (double) megapounds;
-            return new Mass(value, MassUnit.Megapound);
+            return new Mass(megapounds, MassUnit.Megapound);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megatonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMegatonnes(QuantityValue megatonnes)
+        public static Mass FromMegatonnes(double megatonnes)
         {
-            double value = (double) megatonnes;
-            return new Mass(value, MassUnit.Megatonne);
+            return new Mass(megatonnes, MassUnit.Megatonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Microgram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMicrograms(QuantityValue micrograms)
+        public static Mass FromMicrograms(double micrograms)
         {
-            double value = (double) micrograms;
-            return new Mass(value, MassUnit.Microgram);
+            return new Mass(micrograms, MassUnit.Microgram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Milligram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMilligrams(QuantityValue milligrams)
+        public static Mass FromMilligrams(double milligrams)
         {
-            double value = (double) milligrams;
-            return new Mass(value, MassUnit.Milligram);
+            return new Mass(milligrams, MassUnit.Milligram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Nanogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromNanograms(QuantityValue nanograms)
+        public static Mass FromNanograms(double nanograms)
         {
-            double value = (double) nanograms;
-            return new Mass(value, MassUnit.Nanogram);
+            return new Mass(nanograms, MassUnit.Nanogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Ounce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromOunces(QuantityValue ounces)
+        public static Mass FromOunces(double ounces)
         {
-            double value = (double) ounces;
-            return new Mass(value, MassUnit.Ounce);
+            return new Mass(ounces, MassUnit.Ounce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Picogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromPicograms(QuantityValue picograms)
+        public static Mass FromPicograms(double picograms)
         {
-            double value = (double) picograms;
-            return new Mass(value, MassUnit.Picogram);
+            return new Mass(picograms, MassUnit.Picogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Pound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromPounds(QuantityValue pounds)
+        public static Mass FromPounds(double pounds)
         {
-            double value = (double) pounds;
-            return new Mass(value, MassUnit.Pound);
+            return new Mass(pounds, MassUnit.Pound);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.ShortHundredweight"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromShortHundredweight(QuantityValue shorthundredweight)
+        public static Mass FromShortHundredweight(double shorthundredweight)
         {
-            double value = (double) shorthundredweight;
-            return new Mass(value, MassUnit.ShortHundredweight);
+            return new Mass(shorthundredweight, MassUnit.ShortHundredweight);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.ShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromShortTons(QuantityValue shorttons)
+        public static Mass FromShortTons(double shorttons)
         {
-            double value = (double) shorttons;
-            return new Mass(value, MassUnit.ShortTon);
+            return new Mass(shorttons, MassUnit.ShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Slug"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromSlugs(QuantityValue slugs)
+        public static Mass FromSlugs(double slugs)
         {
-            double value = (double) slugs;
-            return new Mass(value, MassUnit.Slug);
+            return new Mass(slugs, MassUnit.Slug);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.SolarMass"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromSolarMasses(QuantityValue solarmasses)
+        public static Mass FromSolarMasses(double solarmasses)
         {
-            double value = (double) solarmasses;
-            return new Mass(value, MassUnit.SolarMass);
+            return new Mass(solarmasses, MassUnit.SolarMass);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Stone"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromStone(QuantityValue stone)
+        public static Mass FromStone(double stone)
         {
-            double value = (double) stone;
-            return new Mass(value, MassUnit.Stone);
+            return new Mass(stone, MassUnit.Stone);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Tonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromTonnes(QuantityValue tonnes)
+        public static Mass FromTonnes(double tonnes)
         {
-            double value = (double) tonnes;
-            return new Mass(value, MassUnit.Tonne);
+            return new Mass(tonnes, MassUnit.Tonne);
         }
 
         /// <summary>
@@ -721,9 +694,9 @@ public static Mass FromTonnes(QuantityValue tonnes)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Mass unit value.</returns>
-        public static Mass From(QuantityValue value, MassUnit fromUnit)
+        public static Mass From(double value, MassUnit fromUnit)
         {
-            return new Mass((double)value, fromUnit);
+            return new Mass(value, fromUnit);
         }
 
         #endregion
@@ -1228,15 +1201,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MassUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MassUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassUnit)} is supported.", nameof(unit));
@@ -1403,18 +1367,6 @@ public Mass ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassUnit> IQuantity<MassUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MassUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
index ee8c291022..5c3625f8f9 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct MassConcentration :
-        IArithmeticQuantity<MassConcentration, MassConcentrationUnit, double>,
+        IArithmeticQuantity<MassConcentration, MassConcentrationUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<MassConcentration, Volume, Mass>,
         IDivisionOperators<MassConcentration, MolarMass, Molarity>,
@@ -206,7 +206,7 @@ public MassConcentration(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -616,490 +616,441 @@ public static string GetAbbreviation(MassConcentrationUnit unit, IFormatProvider
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerDeciliter(QuantityValue centigramsperdeciliter)
+        public static MassConcentration FromCentigramsPerDeciliter(double centigramsperdeciliter)
         {
-            double value = (double) centigramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.CentigramPerDeciliter);
+            return new MassConcentration(centigramsperdeciliter, MassConcentrationUnit.CentigramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerLiter(QuantityValue centigramsperliter)
+        public static MassConcentration FromCentigramsPerLiter(double centigramsperliter)
         {
-            double value = (double) centigramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.CentigramPerLiter);
+            return new MassConcentration(centigramsperliter, MassConcentrationUnit.CentigramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerMicroliter(QuantityValue centigramspermicroliter)
+        public static MassConcentration FromCentigramsPerMicroliter(double centigramspermicroliter)
         {
-            double value = (double) centigramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.CentigramPerMicroliter);
+            return new MassConcentration(centigramspermicroliter, MassConcentrationUnit.CentigramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerMilliliter(QuantityValue centigramspermilliliter)
+        public static MassConcentration FromCentigramsPerMilliliter(double centigramspermilliliter)
         {
-            double value = (double) centigramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.CentigramPerMilliliter);
+            return new MassConcentration(centigramspermilliliter, MassConcentrationUnit.CentigramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerDeciliter(QuantityValue decigramsperdeciliter)
+        public static MassConcentration FromDecigramsPerDeciliter(double decigramsperdeciliter)
         {
-            double value = (double) decigramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.DecigramPerDeciliter);
+            return new MassConcentration(decigramsperdeciliter, MassConcentrationUnit.DecigramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerLiter(QuantityValue decigramsperliter)
+        public static MassConcentration FromDecigramsPerLiter(double decigramsperliter)
         {
-            double value = (double) decigramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.DecigramPerLiter);
+            return new MassConcentration(decigramsperliter, MassConcentrationUnit.DecigramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerMicroliter(QuantityValue decigramspermicroliter)
+        public static MassConcentration FromDecigramsPerMicroliter(double decigramspermicroliter)
         {
-            double value = (double) decigramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.DecigramPerMicroliter);
+            return new MassConcentration(decigramspermicroliter, MassConcentrationUnit.DecigramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerMilliliter(QuantityValue decigramspermilliliter)
+        public static MassConcentration FromDecigramsPerMilliliter(double decigramspermilliliter)
         {
-            double value = (double) decigramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.DecigramPerMilliliter);
+            return new MassConcentration(decigramspermilliliter, MassConcentrationUnit.DecigramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicCentimeter(QuantityValue gramspercubiccentimeter)
+        public static MassConcentration FromGramsPerCubicCentimeter(double gramspercubiccentimeter)
         {
-            double value = (double) gramspercubiccentimeter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicCentimeter);
+            return new MassConcentration(gramspercubiccentimeter, MassConcentrationUnit.GramPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicMeter(QuantityValue gramspercubicmeter)
+        public static MassConcentration FromGramsPerCubicMeter(double gramspercubicmeter)
         {
-            double value = (double) gramspercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMeter);
+            return new MassConcentration(gramspercubicmeter, MassConcentrationUnit.GramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicMillimeter(QuantityValue gramspercubicmillimeter)
+        public static MassConcentration FromGramsPerCubicMillimeter(double gramspercubicmillimeter)
         {
-            double value = (double) gramspercubicmillimeter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMillimeter);
+            return new MassConcentration(gramspercubicmillimeter, MassConcentrationUnit.GramPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerDeciliter(QuantityValue gramsperdeciliter)
+        public static MassConcentration FromGramsPerDeciliter(double gramsperdeciliter)
         {
-            double value = (double) gramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerDeciliter);
+            return new MassConcentration(gramsperdeciliter, MassConcentrationUnit.GramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerLiter(QuantityValue gramsperliter)
+        public static MassConcentration FromGramsPerLiter(double gramsperliter)
         {
-            double value = (double) gramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerLiter);
+            return new MassConcentration(gramsperliter, MassConcentrationUnit.GramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerMicroliter(QuantityValue gramspermicroliter)
+        public static MassConcentration FromGramsPerMicroliter(double gramspermicroliter)
         {
-            double value = (double) gramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerMicroliter);
+            return new MassConcentration(gramspermicroliter, MassConcentrationUnit.GramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerMilliliter(QuantityValue gramspermilliliter)
+        public static MassConcentration FromGramsPerMilliliter(double gramspermilliliter)
         {
-            double value = (double) gramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.GramPerMilliliter);
+            return new MassConcentration(gramspermilliliter, MassConcentrationUnit.GramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicCentimeter(QuantityValue kilogramspercubiccentimeter)
+        public static MassConcentration FromKilogramsPerCubicCentimeter(double kilogramspercubiccentimeter)
         {
-            double value = (double) kilogramspercubiccentimeter;
-            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicCentimeter);
+            return new MassConcentration(kilogramspercubiccentimeter, MassConcentrationUnit.KilogramPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicMeter(QuantityValue kilogramspercubicmeter)
+        public static MassConcentration FromKilogramsPerCubicMeter(double kilogramspercubicmeter)
         {
-            double value = (double) kilogramspercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMeter);
+            return new MassConcentration(kilogramspercubicmeter, MassConcentrationUnit.KilogramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicMillimeter(QuantityValue kilogramspercubicmillimeter)
+        public static MassConcentration FromKilogramsPerCubicMillimeter(double kilogramspercubicmillimeter)
         {
-            double value = (double) kilogramspercubicmillimeter;
-            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMillimeter);
+            return new MassConcentration(kilogramspercubicmillimeter, MassConcentrationUnit.KilogramPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerLiter(QuantityValue kilogramsperliter)
+        public static MassConcentration FromKilogramsPerLiter(double kilogramsperliter)
         {
-            double value = (double) kilogramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.KilogramPerLiter);
+            return new MassConcentration(kilogramsperliter, MassConcentrationUnit.KilogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilopoundPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilopoundsPerCubicFoot(QuantityValue kilopoundspercubicfoot)
+        public static MassConcentration FromKilopoundsPerCubicFoot(double kilopoundspercubicfoot)
         {
-            double value = (double) kilopoundspercubicfoot;
-            return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicFoot);
+            return new MassConcentration(kilopoundspercubicfoot, MassConcentrationUnit.KilopoundPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilopoundPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilopoundsPerCubicInch(QuantityValue kilopoundspercubicinch)
+        public static MassConcentration FromKilopoundsPerCubicInch(double kilopoundspercubicinch)
         {
-            double value = (double) kilopoundspercubicinch;
-            return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicInch);
+            return new MassConcentration(kilopoundspercubicinch, MassConcentrationUnit.KilopoundPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerCubicMeter(QuantityValue microgramspercubicmeter)
+        public static MassConcentration FromMicrogramsPerCubicMeter(double microgramspercubicmeter)
         {
-            double value = (double) microgramspercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerCubicMeter);
+            return new MassConcentration(microgramspercubicmeter, MassConcentrationUnit.MicrogramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerDeciliter(QuantityValue microgramsperdeciliter)
+        public static MassConcentration FromMicrogramsPerDeciliter(double microgramsperdeciliter)
         {
-            double value = (double) microgramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerDeciliter);
+            return new MassConcentration(microgramsperdeciliter, MassConcentrationUnit.MicrogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerLiter(QuantityValue microgramsperliter)
+        public static MassConcentration FromMicrogramsPerLiter(double microgramsperliter)
         {
-            double value = (double) microgramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerLiter);
+            return new MassConcentration(microgramsperliter, MassConcentrationUnit.MicrogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerMicroliter(QuantityValue microgramspermicroliter)
+        public static MassConcentration FromMicrogramsPerMicroliter(double microgramspermicroliter)
         {
-            double value = (double) microgramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMicroliter);
+            return new MassConcentration(microgramspermicroliter, MassConcentrationUnit.MicrogramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerMilliliter(QuantityValue microgramspermilliliter)
+        public static MassConcentration FromMicrogramsPerMilliliter(double microgramspermilliliter)
         {
-            double value = (double) microgramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMilliliter);
+            return new MassConcentration(microgramspermilliliter, MassConcentrationUnit.MicrogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerCubicMeter(QuantityValue milligramspercubicmeter)
+        public static MassConcentration FromMilligramsPerCubicMeter(double milligramspercubicmeter)
         {
-            double value = (double) milligramspercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerCubicMeter);
+            return new MassConcentration(milligramspercubicmeter, MassConcentrationUnit.MilligramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerDeciliter(QuantityValue milligramsperdeciliter)
+        public static MassConcentration FromMilligramsPerDeciliter(double milligramsperdeciliter)
         {
-            double value = (double) milligramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerDeciliter);
+            return new MassConcentration(milligramsperdeciliter, MassConcentrationUnit.MilligramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerLiter(QuantityValue milligramsperliter)
+        public static MassConcentration FromMilligramsPerLiter(double milligramsperliter)
         {
-            double value = (double) milligramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerLiter);
+            return new MassConcentration(milligramsperliter, MassConcentrationUnit.MilligramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerMicroliter(QuantityValue milligramspermicroliter)
+        public static MassConcentration FromMilligramsPerMicroliter(double milligramspermicroliter)
         {
-            double value = (double) milligramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerMicroliter);
+            return new MassConcentration(milligramspermicroliter, MassConcentrationUnit.MilligramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerMilliliter(QuantityValue milligramspermilliliter)
+        public static MassConcentration FromMilligramsPerMilliliter(double milligramspermilliliter)
         {
-            double value = (double) milligramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.MilligramPerMilliliter);
+            return new MassConcentration(milligramspermilliliter, MassConcentrationUnit.MilligramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerDeciliter(QuantityValue nanogramsperdeciliter)
+        public static MassConcentration FromNanogramsPerDeciliter(double nanogramsperdeciliter)
         {
-            double value = (double) nanogramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.NanogramPerDeciliter);
+            return new MassConcentration(nanogramsperdeciliter, MassConcentrationUnit.NanogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerLiter(QuantityValue nanogramsperliter)
+        public static MassConcentration FromNanogramsPerLiter(double nanogramsperliter)
         {
-            double value = (double) nanogramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.NanogramPerLiter);
+            return new MassConcentration(nanogramsperliter, MassConcentrationUnit.NanogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerMicroliter(QuantityValue nanogramspermicroliter)
+        public static MassConcentration FromNanogramsPerMicroliter(double nanogramspermicroliter)
         {
-            double value = (double) nanogramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.NanogramPerMicroliter);
+            return new MassConcentration(nanogramspermicroliter, MassConcentrationUnit.NanogramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerMilliliter(QuantityValue nanogramspermilliliter)
+        public static MassConcentration FromNanogramsPerMilliliter(double nanogramspermilliliter)
         {
-            double value = (double) nanogramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter);
+            return new MassConcentration(nanogramspermilliliter, MassConcentrationUnit.NanogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.OuncePerImperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromOuncesPerImperialGallon(QuantityValue ouncesperimperialgallon)
+        public static MassConcentration FromOuncesPerImperialGallon(double ouncesperimperialgallon)
         {
-            double value = (double) ouncesperimperialgallon;
-            return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon);
+            return new MassConcentration(ouncesperimperialgallon, MassConcentrationUnit.OuncePerImperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.OuncePerUSGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromOuncesPerUSGallon(QuantityValue ouncesperusgallon)
+        public static MassConcentration FromOuncesPerUSGallon(double ouncesperusgallon)
         {
-            double value = (double) ouncesperusgallon;
-            return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon);
+            return new MassConcentration(ouncesperusgallon, MassConcentrationUnit.OuncePerUSGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerDeciliter(QuantityValue picogramsperdeciliter)
+        public static MassConcentration FromPicogramsPerDeciliter(double picogramsperdeciliter)
         {
-            double value = (double) picogramsperdeciliter;
-            return new MassConcentration(value, MassConcentrationUnit.PicogramPerDeciliter);
+            return new MassConcentration(picogramsperdeciliter, MassConcentrationUnit.PicogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerLiter(QuantityValue picogramsperliter)
+        public static MassConcentration FromPicogramsPerLiter(double picogramsperliter)
         {
-            double value = (double) picogramsperliter;
-            return new MassConcentration(value, MassConcentrationUnit.PicogramPerLiter);
+            return new MassConcentration(picogramsperliter, MassConcentrationUnit.PicogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerMicroliter(QuantityValue picogramspermicroliter)
+        public static MassConcentration FromPicogramsPerMicroliter(double picogramspermicroliter)
         {
-            double value = (double) picogramspermicroliter;
-            return new MassConcentration(value, MassConcentrationUnit.PicogramPerMicroliter);
+            return new MassConcentration(picogramspermicroliter, MassConcentrationUnit.PicogramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerMilliliter(QuantityValue picogramspermilliliter)
+        public static MassConcentration FromPicogramsPerMilliliter(double picogramspermilliliter)
         {
-            double value = (double) picogramspermilliliter;
-            return new MassConcentration(value, MassConcentrationUnit.PicogramPerMilliliter);
+            return new MassConcentration(picogramspermilliliter, MassConcentrationUnit.PicogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerCubicFoot(QuantityValue poundspercubicfoot)
+        public static MassConcentration FromPoundsPerCubicFoot(double poundspercubicfoot)
         {
-            double value = (double) poundspercubicfoot;
-            return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicFoot);
+            return new MassConcentration(poundspercubicfoot, MassConcentrationUnit.PoundPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerCubicInch(QuantityValue poundspercubicinch)
+        public static MassConcentration FromPoundsPerCubicInch(double poundspercubicinch)
         {
-            double value = (double) poundspercubicinch;
-            return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicInch);
+            return new MassConcentration(poundspercubicinch, MassConcentrationUnit.PoundPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerImperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerImperialGallon(QuantityValue poundsperimperialgallon)
+        public static MassConcentration FromPoundsPerImperialGallon(double poundsperimperialgallon)
         {
-            double value = (double) poundsperimperialgallon;
-            return new MassConcentration(value, MassConcentrationUnit.PoundPerImperialGallon);
+            return new MassConcentration(poundsperimperialgallon, MassConcentrationUnit.PoundPerImperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerUSGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerUSGallon(QuantityValue poundsperusgallon)
+        public static MassConcentration FromPoundsPerUSGallon(double poundsperusgallon)
         {
-            double value = (double) poundsperusgallon;
-            return new MassConcentration(value, MassConcentrationUnit.PoundPerUSGallon);
+            return new MassConcentration(poundsperusgallon, MassConcentrationUnit.PoundPerUSGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.SlugPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromSlugsPerCubicFoot(QuantityValue slugspercubicfoot)
+        public static MassConcentration FromSlugsPerCubicFoot(double slugspercubicfoot)
         {
-            double value = (double) slugspercubicfoot;
-            return new MassConcentration(value, MassConcentrationUnit.SlugPerCubicFoot);
+            return new MassConcentration(slugspercubicfoot, MassConcentrationUnit.SlugPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicCentimeter(QuantityValue tonnespercubiccentimeter)
+        public static MassConcentration FromTonnesPerCubicCentimeter(double tonnespercubiccentimeter)
         {
-            double value = (double) tonnespercubiccentimeter;
-            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicCentimeter);
+            return new MassConcentration(tonnespercubiccentimeter, MassConcentrationUnit.TonnePerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicMeter(QuantityValue tonnespercubicmeter)
+        public static MassConcentration FromTonnesPerCubicMeter(double tonnespercubicmeter)
         {
-            double value = (double) tonnespercubicmeter;
-            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMeter);
+            return new MassConcentration(tonnespercubicmeter, MassConcentrationUnit.TonnePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicMillimeter(QuantityValue tonnespercubicmillimeter)
+        public static MassConcentration FromTonnesPerCubicMillimeter(double tonnespercubicmillimeter)
         {
-            double value = (double) tonnespercubicmillimeter;
-            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMillimeter);
+            return new MassConcentration(tonnespercubicmillimeter, MassConcentrationUnit.TonnePerCubicMillimeter);
         }
 
         /// <summary>
@@ -1108,9 +1059,9 @@ public static MassConcentration FromTonnesPerCubicMillimeter(QuantityValue tonne
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassConcentration unit value.</returns>
-        public static MassConcentration From(QuantityValue value, MassConcentrationUnit fromUnit)
+        public static MassConcentration From(double value, MassConcentrationUnit fromUnit)
         {
-            return new MassConcentration((double)value, fromUnit);
+            return new MassConcentration(value, fromUnit);
         }
 
         #endregion
@@ -1543,15 +1494,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MassConcentrationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassConcentrationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MassConcentrationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassConcentrationUnit)} is supported.", nameof(unit));
@@ -1762,18 +1704,6 @@ public MassConcentration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassConcentrationUnit> IQuantity<MassConcentrationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MassConcentrationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassConcentrationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
index bc6331a141..07ecac8e86 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct MassFlow :
-        IArithmeticQuantity<MassFlow, MassFlowUnit, double>,
+        IArithmeticQuantity<MassFlow, MassFlowUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<MassFlow, MassFlux, Area>,
         IDivisionOperators<MassFlow, Power, BrakeSpecificFuelConsumption>,
@@ -193,7 +193,7 @@ public MassFlow(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -491,330 +491,297 @@ public static string GetAbbreviation(MassFlowUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.CentigramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromCentigramsPerDay(QuantityValue centigramsperday)
+        public static MassFlow FromCentigramsPerDay(double centigramsperday)
         {
-            double value = (double) centigramsperday;
-            return new MassFlow(value, MassFlowUnit.CentigramPerDay);
+            return new MassFlow(centigramsperday, MassFlowUnit.CentigramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.CentigramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromCentigramsPerSecond(QuantityValue centigramspersecond)
+        public static MassFlow FromCentigramsPerSecond(double centigramspersecond)
         {
-            double value = (double) centigramspersecond;
-            return new MassFlow(value, MassFlowUnit.CentigramPerSecond);
+            return new MassFlow(centigramspersecond, MassFlowUnit.CentigramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecagramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecagramsPerDay(QuantityValue decagramsperday)
+        public static MassFlow FromDecagramsPerDay(double decagramsperday)
         {
-            double value = (double) decagramsperday;
-            return new MassFlow(value, MassFlowUnit.DecagramPerDay);
+            return new MassFlow(decagramsperday, MassFlowUnit.DecagramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecagramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecagramsPerSecond(QuantityValue decagramspersecond)
+        public static MassFlow FromDecagramsPerSecond(double decagramspersecond)
         {
-            double value = (double) decagramspersecond;
-            return new MassFlow(value, MassFlowUnit.DecagramPerSecond);
+            return new MassFlow(decagramspersecond, MassFlowUnit.DecagramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecigramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecigramsPerDay(QuantityValue decigramsperday)
+        public static MassFlow FromDecigramsPerDay(double decigramsperday)
         {
-            double value = (double) decigramsperday;
-            return new MassFlow(value, MassFlowUnit.DecigramPerDay);
+            return new MassFlow(decigramsperday, MassFlowUnit.DecigramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecigramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecigramsPerSecond(QuantityValue decigramspersecond)
+        public static MassFlow FromDecigramsPerSecond(double decigramspersecond)
         {
-            double value = (double) decigramspersecond;
-            return new MassFlow(value, MassFlowUnit.DecigramPerSecond);
+            return new MassFlow(decigramspersecond, MassFlowUnit.DecigramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerDay(QuantityValue gramsperday)
+        public static MassFlow FromGramsPerDay(double gramsperday)
         {
-            double value = (double) gramsperday;
-            return new MassFlow(value, MassFlowUnit.GramPerDay);
+            return new MassFlow(gramsperday, MassFlowUnit.GramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerHour(QuantityValue gramsperhour)
+        public static MassFlow FromGramsPerHour(double gramsperhour)
         {
-            double value = (double) gramsperhour;
-            return new MassFlow(value, MassFlowUnit.GramPerHour);
+            return new MassFlow(gramsperhour, MassFlowUnit.GramPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerSecond(QuantityValue gramspersecond)
+        public static MassFlow FromGramsPerSecond(double gramspersecond)
         {
-            double value = (double) gramspersecond;
-            return new MassFlow(value, MassFlowUnit.GramPerSecond);
+            return new MassFlow(gramspersecond, MassFlowUnit.GramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.HectogramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromHectogramsPerDay(QuantityValue hectogramsperday)
+        public static MassFlow FromHectogramsPerDay(double hectogramsperday)
         {
-            double value = (double) hectogramsperday;
-            return new MassFlow(value, MassFlowUnit.HectogramPerDay);
+            return new MassFlow(hectogramsperday, MassFlowUnit.HectogramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.HectogramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromHectogramsPerSecond(QuantityValue hectogramspersecond)
+        public static MassFlow FromHectogramsPerSecond(double hectogramspersecond)
         {
-            double value = (double) hectogramspersecond;
-            return new MassFlow(value, MassFlowUnit.HectogramPerSecond);
+            return new MassFlow(hectogramspersecond, MassFlowUnit.HectogramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerDay(QuantityValue kilogramsperday)
+        public static MassFlow FromKilogramsPerDay(double kilogramsperday)
         {
-            double value = (double) kilogramsperday;
-            return new MassFlow(value, MassFlowUnit.KilogramPerDay);
+            return new MassFlow(kilogramsperday, MassFlowUnit.KilogramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerHour(QuantityValue kilogramsperhour)
+        public static MassFlow FromKilogramsPerHour(double kilogramsperhour)
         {
-            double value = (double) kilogramsperhour;
-            return new MassFlow(value, MassFlowUnit.KilogramPerHour);
+            return new MassFlow(kilogramsperhour, MassFlowUnit.KilogramPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerMinute(QuantityValue kilogramsperminute)
+        public static MassFlow FromKilogramsPerMinute(double kilogramsperminute)
         {
-            double value = (double) kilogramsperminute;
-            return new MassFlow(value, MassFlowUnit.KilogramPerMinute);
+            return new MassFlow(kilogramsperminute, MassFlowUnit.KilogramPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerSecond(QuantityValue kilogramspersecond)
+        public static MassFlow FromKilogramsPerSecond(double kilogramspersecond)
         {
-            double value = (double) kilogramspersecond;
-            return new MassFlow(value, MassFlowUnit.KilogramPerSecond);
+            return new MassFlow(kilogramspersecond, MassFlowUnit.KilogramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegagramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegagramsPerDay(QuantityValue megagramsperday)
+        public static MassFlow FromMegagramsPerDay(double megagramsperday)
         {
-            double value = (double) megagramsperday;
-            return new MassFlow(value, MassFlowUnit.MegagramPerDay);
+            return new MassFlow(megagramsperday, MassFlowUnit.MegagramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerDay(QuantityValue megapoundsperday)
+        public static MassFlow FromMegapoundsPerDay(double megapoundsperday)
         {
-            double value = (double) megapoundsperday;
-            return new MassFlow(value, MassFlowUnit.MegapoundPerDay);
+            return new MassFlow(megapoundsperday, MassFlowUnit.MegapoundPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerHour(QuantityValue megapoundsperhour)
+        public static MassFlow FromMegapoundsPerHour(double megapoundsperhour)
         {
-            double value = (double) megapoundsperhour;
-            return new MassFlow(value, MassFlowUnit.MegapoundPerHour);
+            return new MassFlow(megapoundsperhour, MassFlowUnit.MegapoundPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerMinute(QuantityValue megapoundsperminute)
+        public static MassFlow FromMegapoundsPerMinute(double megapoundsperminute)
         {
-            double value = (double) megapoundsperminute;
-            return new MassFlow(value, MassFlowUnit.MegapoundPerMinute);
+            return new MassFlow(megapoundsperminute, MassFlowUnit.MegapoundPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerSecond(QuantityValue megapoundspersecond)
+        public static MassFlow FromMegapoundsPerSecond(double megapoundspersecond)
         {
-            double value = (double) megapoundspersecond;
-            return new MassFlow(value, MassFlowUnit.MegapoundPerSecond);
+            return new MassFlow(megapoundspersecond, MassFlowUnit.MegapoundPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MicrogramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMicrogramsPerDay(QuantityValue microgramsperday)
+        public static MassFlow FromMicrogramsPerDay(double microgramsperday)
         {
-            double value = (double) microgramsperday;
-            return new MassFlow(value, MassFlowUnit.MicrogramPerDay);
+            return new MassFlow(microgramsperday, MassFlowUnit.MicrogramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MicrogramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMicrogramsPerSecond(QuantityValue microgramspersecond)
+        public static MassFlow FromMicrogramsPerSecond(double microgramspersecond)
         {
-            double value = (double) microgramspersecond;
-            return new MassFlow(value, MassFlowUnit.MicrogramPerSecond);
+            return new MassFlow(microgramspersecond, MassFlowUnit.MicrogramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MilligramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMilligramsPerDay(QuantityValue milligramsperday)
+        public static MassFlow FromMilligramsPerDay(double milligramsperday)
         {
-            double value = (double) milligramsperday;
-            return new MassFlow(value, MassFlowUnit.MilligramPerDay);
+            return new MassFlow(milligramsperday, MassFlowUnit.MilligramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MilligramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMilligramsPerSecond(QuantityValue milligramspersecond)
+        public static MassFlow FromMilligramsPerSecond(double milligramspersecond)
         {
-            double value = (double) milligramspersecond;
-            return new MassFlow(value, MassFlowUnit.MilligramPerSecond);
+            return new MassFlow(milligramspersecond, MassFlowUnit.MilligramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.NanogramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromNanogramsPerDay(QuantityValue nanogramsperday)
+        public static MassFlow FromNanogramsPerDay(double nanogramsperday)
         {
-            double value = (double) nanogramsperday;
-            return new MassFlow(value, MassFlowUnit.NanogramPerDay);
+            return new MassFlow(nanogramsperday, MassFlowUnit.NanogramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.NanogramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromNanogramsPerSecond(QuantityValue nanogramspersecond)
+        public static MassFlow FromNanogramsPerSecond(double nanogramspersecond)
         {
-            double value = (double) nanogramspersecond;
-            return new MassFlow(value, MassFlowUnit.NanogramPerSecond);
+            return new MassFlow(nanogramspersecond, MassFlowUnit.NanogramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerDay(QuantityValue poundsperday)
+        public static MassFlow FromPoundsPerDay(double poundsperday)
         {
-            double value = (double) poundsperday;
-            return new MassFlow(value, MassFlowUnit.PoundPerDay);
+            return new MassFlow(poundsperday, MassFlowUnit.PoundPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerHour(QuantityValue poundsperhour)
+        public static MassFlow FromPoundsPerHour(double poundsperhour)
         {
-            double value = (double) poundsperhour;
-            return new MassFlow(value, MassFlowUnit.PoundPerHour);
+            return new MassFlow(poundsperhour, MassFlowUnit.PoundPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerMinute(QuantityValue poundsperminute)
+        public static MassFlow FromPoundsPerMinute(double poundsperminute)
         {
-            double value = (double) poundsperminute;
-            return new MassFlow(value, MassFlowUnit.PoundPerMinute);
+            return new MassFlow(poundsperminute, MassFlowUnit.PoundPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerSecond(QuantityValue poundspersecond)
+        public static MassFlow FromPoundsPerSecond(double poundspersecond)
         {
-            double value = (double) poundspersecond;
-            return new MassFlow(value, MassFlowUnit.PoundPerSecond);
+            return new MassFlow(poundspersecond, MassFlowUnit.PoundPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.ShortTonPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromShortTonsPerHour(QuantityValue shorttonsperhour)
+        public static MassFlow FromShortTonsPerHour(double shorttonsperhour)
         {
-            double value = (double) shorttonsperhour;
-            return new MassFlow(value, MassFlowUnit.ShortTonPerHour);
+            return new MassFlow(shorttonsperhour, MassFlowUnit.ShortTonPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.TonnePerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromTonnesPerDay(QuantityValue tonnesperday)
+        public static MassFlow FromTonnesPerDay(double tonnesperday)
         {
-            double value = (double) tonnesperday;
-            return new MassFlow(value, MassFlowUnit.TonnePerDay);
+            return new MassFlow(tonnesperday, MassFlowUnit.TonnePerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.TonnePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromTonnesPerHour(QuantityValue tonnesperhour)
+        public static MassFlow FromTonnesPerHour(double tonnesperhour)
         {
-            double value = (double) tonnesperhour;
-            return new MassFlow(value, MassFlowUnit.TonnePerHour);
+            return new MassFlow(tonnesperhour, MassFlowUnit.TonnePerHour);
         }
 
         /// <summary>
@@ -823,9 +790,9 @@ public static MassFlow FromTonnesPerHour(QuantityValue tonnesperhour)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassFlow unit value.</returns>
-        public static MassFlow From(QuantityValue value, MassFlowUnit fromUnit)
+        public static MassFlow From(double value, MassFlowUnit fromUnit)
         {
-            return new MassFlow((double)value, fromUnit);
+            return new MassFlow(value, fromUnit);
         }
 
         #endregion
@@ -1300,15 +1267,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MassFlowUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFlowUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MassFlowUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFlowUnit)} is supported.", nameof(unit));
@@ -1487,18 +1445,6 @@ public MassFlow ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassFlowUnit> IQuantity<MassFlowUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MassFlowUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFlowUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
index 74dae04d8c..5e65d320c1 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct MassFlux :
-        IArithmeticQuantity<MassFlux, MassFluxUnit, double>,
+        IArithmeticQuantity<MassFlux, MassFluxUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<MassFlux, Speed, Density>,
         IMultiplyOperators<MassFlux, Area, MassFlow>,
@@ -166,7 +166,7 @@ public MassFlux(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -317,120 +317,108 @@ public static string GetAbbreviation(MassFluxUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareCentimeter(QuantityValue gramsperhourpersquarecentimeter)
+        public static MassFlux FromGramsPerHourPerSquareCentimeter(double gramsperhourpersquarecentimeter)
         {
-            double value = (double) gramsperhourpersquarecentimeter;
-            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareCentimeter);
+            return new MassFlux(gramsperhourpersquarecentimeter, MassFluxUnit.GramPerHourPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareMeter(QuantityValue gramsperhourpersquaremeter)
+        public static MassFlux FromGramsPerHourPerSquareMeter(double gramsperhourpersquaremeter)
         {
-            double value = (double) gramsperhourpersquaremeter;
-            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMeter);
+            return new MassFlux(gramsperhourpersquaremeter, MassFluxUnit.GramPerHourPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareMillimeter(QuantityValue gramsperhourpersquaremillimeter)
+        public static MassFlux FromGramsPerHourPerSquareMillimeter(double gramsperhourpersquaremillimeter)
         {
-            double value = (double) gramsperhourpersquaremillimeter;
-            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMillimeter);
+            return new MassFlux(gramsperhourpersquaremillimeter, MassFluxUnit.GramPerHourPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareCentimeter(QuantityValue gramspersecondpersquarecentimeter)
+        public static MassFlux FromGramsPerSecondPerSquareCentimeter(double gramspersecondpersquarecentimeter)
         {
-            double value = (double) gramspersecondpersquarecentimeter;
-            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareCentimeter);
+            return new MassFlux(gramspersecondpersquarecentimeter, MassFluxUnit.GramPerSecondPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareMeter(QuantityValue gramspersecondpersquaremeter)
+        public static MassFlux FromGramsPerSecondPerSquareMeter(double gramspersecondpersquaremeter)
         {
-            double value = (double) gramspersecondpersquaremeter;
-            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMeter);
+            return new MassFlux(gramspersecondpersquaremeter, MassFluxUnit.GramPerSecondPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareMillimeter(QuantityValue gramspersecondpersquaremillimeter)
+        public static MassFlux FromGramsPerSecondPerSquareMillimeter(double gramspersecondpersquaremillimeter)
         {
-            double value = (double) gramspersecondpersquaremillimeter;
-            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMillimeter);
+            return new MassFlux(gramspersecondpersquaremillimeter, MassFluxUnit.GramPerSecondPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareCentimeter(QuantityValue kilogramsperhourpersquarecentimeter)
+        public static MassFlux FromKilogramsPerHourPerSquareCentimeter(double kilogramsperhourpersquarecentimeter)
         {
-            double value = (double) kilogramsperhourpersquarecentimeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
+            return new MassFlux(kilogramsperhourpersquarecentimeter, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareMeter(QuantityValue kilogramsperhourpersquaremeter)
+        public static MassFlux FromKilogramsPerHourPerSquareMeter(double kilogramsperhourpersquaremeter)
         {
-            double value = (double) kilogramsperhourpersquaremeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMeter);
+            return new MassFlux(kilogramsperhourpersquaremeter, MassFluxUnit.KilogramPerHourPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareMillimeter(QuantityValue kilogramsperhourpersquaremillimeter)
+        public static MassFlux FromKilogramsPerHourPerSquareMillimeter(double kilogramsperhourpersquaremillimeter)
         {
-            double value = (double) kilogramsperhourpersquaremillimeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
+            return new MassFlux(kilogramsperhourpersquaremillimeter, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(QuantityValue kilogramspersecondpersquarecentimeter)
+        public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(double kilogramspersecondpersquarecentimeter)
         {
-            double value = (double) kilogramspersecondpersquarecentimeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
+            return new MassFlux(kilogramspersecondpersquarecentimeter, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareMeter(QuantityValue kilogramspersecondpersquaremeter)
+        public static MassFlux FromKilogramsPerSecondPerSquareMeter(double kilogramspersecondpersquaremeter)
         {
-            double value = (double) kilogramspersecondpersquaremeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMeter);
+            return new MassFlux(kilogramspersecondpersquaremeter, MassFluxUnit.KilogramPerSecondPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(QuantityValue kilogramspersecondpersquaremillimeter)
+        public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(double kilogramspersecondpersquaremillimeter)
         {
-            double value = (double) kilogramspersecondpersquaremillimeter;
-            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
+            return new MassFlux(kilogramspersecondpersquaremillimeter, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
         }
 
         /// <summary>
@@ -439,9 +427,9 @@ public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(QuantityValue k
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassFlux unit value.</returns>
-        public static MassFlux From(QuantityValue value, MassFluxUnit fromUnit)
+        public static MassFlux From(double value, MassFluxUnit fromUnit)
         {
-            return new MassFlux((double)value, fromUnit);
+            return new MassFlux(value, fromUnit);
         }
 
         #endregion
@@ -874,15 +862,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MassFluxUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFluxUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MassFluxUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFluxUnit)} is supported.", nameof(unit));
@@ -1019,18 +998,6 @@ public MassFlux ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassFluxUnit> IQuantity<MassFluxUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MassFluxUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFluxUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
index 749c8a47c6..391b74441d 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct MassFraction :
-        IArithmeticQuantity<MassFraction, MassFractionUnit, double>,
+        IArithmeticQuantity<MassFraction, MassFractionUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<MassFraction, Mass, Mass>,
 #endif
@@ -179,7 +179,7 @@ public MassFraction(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -414,240 +414,216 @@ public static string GetAbbreviation(MassFractionUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.CentigramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromCentigramsPerGram(QuantityValue centigramspergram)
+        public static MassFraction FromCentigramsPerGram(double centigramspergram)
         {
-            double value = (double) centigramspergram;
-            return new MassFraction(value, MassFractionUnit.CentigramPerGram);
+            return new MassFraction(centigramspergram, MassFractionUnit.CentigramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.CentigramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromCentigramsPerKilogram(QuantityValue centigramsperkilogram)
+        public static MassFraction FromCentigramsPerKilogram(double centigramsperkilogram)
         {
-            double value = (double) centigramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.CentigramPerKilogram);
+            return new MassFraction(centigramsperkilogram, MassFractionUnit.CentigramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecagramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecagramsPerGram(QuantityValue decagramspergram)
+        public static MassFraction FromDecagramsPerGram(double decagramspergram)
         {
-            double value = (double) decagramspergram;
-            return new MassFraction(value, MassFractionUnit.DecagramPerGram);
+            return new MassFraction(decagramspergram, MassFractionUnit.DecagramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecagramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecagramsPerKilogram(QuantityValue decagramsperkilogram)
+        public static MassFraction FromDecagramsPerKilogram(double decagramsperkilogram)
         {
-            double value = (double) decagramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.DecagramPerKilogram);
+            return new MassFraction(decagramsperkilogram, MassFractionUnit.DecagramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecigramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecigramsPerGram(QuantityValue decigramspergram)
+        public static MassFraction FromDecigramsPerGram(double decigramspergram)
         {
-            double value = (double) decigramspergram;
-            return new MassFraction(value, MassFractionUnit.DecigramPerGram);
+            return new MassFraction(decigramspergram, MassFractionUnit.DecigramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecigramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecigramsPerKilogram(QuantityValue decigramsperkilogram)
+        public static MassFraction FromDecigramsPerKilogram(double decigramsperkilogram)
         {
-            double value = (double) decigramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.DecigramPerKilogram);
+            return new MassFraction(decigramsperkilogram, MassFractionUnit.DecigramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecimalFraction"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecimalFractions(QuantityValue decimalfractions)
+        public static MassFraction FromDecimalFractions(double decimalfractions)
         {
-            double value = (double) decimalfractions;
-            return new MassFraction(value, MassFractionUnit.DecimalFraction);
+            return new MassFraction(decimalfractions, MassFractionUnit.DecimalFraction);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.GramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromGramsPerGram(QuantityValue gramspergram)
+        public static MassFraction FromGramsPerGram(double gramspergram)
         {
-            double value = (double) gramspergram;
-            return new MassFraction(value, MassFractionUnit.GramPerGram);
+            return new MassFraction(gramspergram, MassFractionUnit.GramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.GramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromGramsPerKilogram(QuantityValue gramsperkilogram)
+        public static MassFraction FromGramsPerKilogram(double gramsperkilogram)
         {
-            double value = (double) gramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.GramPerKilogram);
+            return new MassFraction(gramsperkilogram, MassFractionUnit.GramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.HectogramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromHectogramsPerGram(QuantityValue hectogramspergram)
+        public static MassFraction FromHectogramsPerGram(double hectogramspergram)
         {
-            double value = (double) hectogramspergram;
-            return new MassFraction(value, MassFractionUnit.HectogramPerGram);
+            return new MassFraction(hectogramspergram, MassFractionUnit.HectogramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.HectogramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromHectogramsPerKilogram(QuantityValue hectogramsperkilogram)
+        public static MassFraction FromHectogramsPerKilogram(double hectogramsperkilogram)
         {
-            double value = (double) hectogramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.HectogramPerKilogram);
+            return new MassFraction(hectogramsperkilogram, MassFractionUnit.HectogramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.KilogramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromKilogramsPerGram(QuantityValue kilogramspergram)
+        public static MassFraction FromKilogramsPerGram(double kilogramspergram)
         {
-            double value = (double) kilogramspergram;
-            return new MassFraction(value, MassFractionUnit.KilogramPerGram);
+            return new MassFraction(kilogramspergram, MassFractionUnit.KilogramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.KilogramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromKilogramsPerKilogram(QuantityValue kilogramsperkilogram)
+        public static MassFraction FromKilogramsPerKilogram(double kilogramsperkilogram)
         {
-            double value = (double) kilogramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.KilogramPerKilogram);
+            return new MassFraction(kilogramsperkilogram, MassFractionUnit.KilogramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MicrogramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMicrogramsPerGram(QuantityValue microgramspergram)
+        public static MassFraction FromMicrogramsPerGram(double microgramspergram)
         {
-            double value = (double) microgramspergram;
-            return new MassFraction(value, MassFractionUnit.MicrogramPerGram);
+            return new MassFraction(microgramspergram, MassFractionUnit.MicrogramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MicrogramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMicrogramsPerKilogram(QuantityValue microgramsperkilogram)
+        public static MassFraction FromMicrogramsPerKilogram(double microgramsperkilogram)
         {
-            double value = (double) microgramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.MicrogramPerKilogram);
+            return new MassFraction(microgramsperkilogram, MassFractionUnit.MicrogramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MilligramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMilligramsPerGram(QuantityValue milligramspergram)
+        public static MassFraction FromMilligramsPerGram(double milligramspergram)
         {
-            double value = (double) milligramspergram;
-            return new MassFraction(value, MassFractionUnit.MilligramPerGram);
+            return new MassFraction(milligramspergram, MassFractionUnit.MilligramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MilligramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMilligramsPerKilogram(QuantityValue milligramsperkilogram)
+        public static MassFraction FromMilligramsPerKilogram(double milligramsperkilogram)
         {
-            double value = (double) milligramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.MilligramPerKilogram);
+            return new MassFraction(milligramsperkilogram, MassFractionUnit.MilligramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.NanogramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromNanogramsPerGram(QuantityValue nanogramspergram)
+        public static MassFraction FromNanogramsPerGram(double nanogramspergram)
         {
-            double value = (double) nanogramspergram;
-            return new MassFraction(value, MassFractionUnit.NanogramPerGram);
+            return new MassFraction(nanogramspergram, MassFractionUnit.NanogramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.NanogramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromNanogramsPerKilogram(QuantityValue nanogramsperkilogram)
+        public static MassFraction FromNanogramsPerKilogram(double nanogramsperkilogram)
         {
-            double value = (double) nanogramsperkilogram;
-            return new MassFraction(value, MassFractionUnit.NanogramPerKilogram);
+            return new MassFraction(nanogramsperkilogram, MassFractionUnit.NanogramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerBillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerBillion(QuantityValue partsperbillion)
+        public static MassFraction FromPartsPerBillion(double partsperbillion)
         {
-            double value = (double) partsperbillion;
-            return new MassFraction(value, MassFractionUnit.PartPerBillion);
+            return new MassFraction(partsperbillion, MassFractionUnit.PartPerBillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerMillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerMillion(QuantityValue partspermillion)
+        public static MassFraction FromPartsPerMillion(double partspermillion)
         {
-            double value = (double) partspermillion;
-            return new MassFraction(value, MassFractionUnit.PartPerMillion);
+            return new MassFraction(partspermillion, MassFractionUnit.PartPerMillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerThousand"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerThousand(QuantityValue partsperthousand)
+        public static MassFraction FromPartsPerThousand(double partsperthousand)
         {
-            double value = (double) partsperthousand;
-            return new MassFraction(value, MassFractionUnit.PartPerThousand);
+            return new MassFraction(partsperthousand, MassFractionUnit.PartPerThousand);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerTrillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerTrillion(QuantityValue partspertrillion)
+        public static MassFraction FromPartsPerTrillion(double partspertrillion)
         {
-            double value = (double) partspertrillion;
-            return new MassFraction(value, MassFractionUnit.PartPerTrillion);
+            return new MassFraction(partspertrillion, MassFractionUnit.PartPerTrillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.Percent"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPercent(QuantityValue percent)
+        public static MassFraction FromPercent(double percent)
         {
-            double value = (double) percent;
-            return new MassFraction(value, MassFractionUnit.Percent);
+            return new MassFraction(percent, MassFractionUnit.Percent);
         }
 
         /// <summary>
@@ -656,9 +632,9 @@ public static MassFraction FromPercent(QuantityValue percent)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassFraction unit value.</returns>
-        public static MassFraction From(QuantityValue value, MassFractionUnit fromUnit)
+        public static MassFraction From(double value, MassFractionUnit fromUnit)
         {
-            return new MassFraction((double)value, fromUnit);
+            return new MassFraction(value, fromUnit);
         }
 
         #endregion
@@ -1079,15 +1055,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MassFractionUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFractionUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MassFractionUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFractionUnit)} is supported.", nameof(unit));
@@ -1248,18 +1215,6 @@ public MassFraction ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassFractionUnit> IQuantity<MassFractionUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MassFractionUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassFractionUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
index b1960d57f9..1c0c81e360 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct MassMomentOfInertia :
-        IArithmeticQuantity<MassMomentOfInertia, MassMomentOfInertiaUnit, double>,
+        IArithmeticQuantity<MassMomentOfInertia, MassMomentOfInertiaUnit>,
         IComparable,
         IComparable<MassMomentOfInertia>,
         IConvertible,
@@ -174,7 +174,7 @@ public MassMomentOfInertia(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -437,280 +437,252 @@ public static string GetAbbreviation(MassMomentOfInertiaUnit unit, IFormatProvid
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareCentimeters(QuantityValue gramsquarecentimeters)
+        public static MassMomentOfInertia FromGramSquareCentimeters(double gramsquarecentimeters)
         {
-            double value = (double) gramsquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareCentimeter);
+            return new MassMomentOfInertia(gramsquarecentimeters, MassMomentOfInertiaUnit.GramSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareDecimeters(QuantityValue gramsquaredecimeters)
+        public static MassMomentOfInertia FromGramSquareDecimeters(double gramsquaredecimeters)
         {
-            double value = (double) gramsquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareDecimeter);
+            return new MassMomentOfInertia(gramsquaredecimeters, MassMomentOfInertiaUnit.GramSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareMeters(QuantityValue gramsquaremeters)
+        public static MassMomentOfInertia FromGramSquareMeters(double gramsquaremeters)
         {
-            double value = (double) gramsquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMeter);
+            return new MassMomentOfInertia(gramsquaremeters, MassMomentOfInertiaUnit.GramSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareMillimeters(QuantityValue gramsquaremillimeters)
+        public static MassMomentOfInertia FromGramSquareMillimeters(double gramsquaremillimeters)
         {
-            double value = (double) gramsquaremillimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMillimeter);
+            return new MassMomentOfInertia(gramsquaremillimeters, MassMomentOfInertiaUnit.GramSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareCentimeters(QuantityValue kilogramsquarecentimeters)
+        public static MassMomentOfInertia FromKilogramSquareCentimeters(double kilogramsquarecentimeters)
         {
-            double value = (double) kilogramsquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
+            return new MassMomentOfInertia(kilogramsquarecentimeters, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareDecimeters(QuantityValue kilogramsquaredecimeters)
+        public static MassMomentOfInertia FromKilogramSquareDecimeters(double kilogramsquaredecimeters)
         {
-            double value = (double) kilogramsquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
+            return new MassMomentOfInertia(kilogramsquaredecimeters, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareMeters(QuantityValue kilogramsquaremeters)
+        public static MassMomentOfInertia FromKilogramSquareMeters(double kilogramsquaremeters)
         {
-            double value = (double) kilogramsquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMeter);
+            return new MassMomentOfInertia(kilogramsquaremeters, MassMomentOfInertiaUnit.KilogramSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareMillimeters(QuantityValue kilogramsquaremillimeters)
+        public static MassMomentOfInertia FromKilogramSquareMillimeters(double kilogramsquaremillimeters)
         {
-            double value = (double) kilogramsquaremillimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
+            return new MassMomentOfInertia(kilogramsquaremillimeters, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareCentimeters(QuantityValue kilotonnesquarecentimeters)
+        public static MassMomentOfInertia FromKilotonneSquareCentimeters(double kilotonnesquarecentimeters)
         {
-            double value = (double) kilotonnesquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
+            return new MassMomentOfInertia(kilotonnesquarecentimeters, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareDecimeters(QuantityValue kilotonnesquaredecimeters)
+        public static MassMomentOfInertia FromKilotonneSquareDecimeters(double kilotonnesquaredecimeters)
         {
-            double value = (double) kilotonnesquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
+            return new MassMomentOfInertia(kilotonnesquaredecimeters, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareMeters(QuantityValue kilotonnesquaremeters)
+        public static MassMomentOfInertia FromKilotonneSquareMeters(double kilotonnesquaremeters)
         {
-            double value = (double) kilotonnesquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMeter);
+            return new MassMomentOfInertia(kilotonnesquaremeters, MassMomentOfInertiaUnit.KilotonneSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareMilimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareMilimeters(QuantityValue kilotonnesquaremilimeters)
+        public static MassMomentOfInertia FromKilotonneSquareMilimeters(double kilotonnesquaremilimeters)
         {
-            double value = (double) kilotonnesquaremilimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
+            return new MassMomentOfInertia(kilotonnesquaremilimeters, MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareCentimeters(QuantityValue megatonnesquarecentimeters)
+        public static MassMomentOfInertia FromMegatonneSquareCentimeters(double megatonnesquarecentimeters)
         {
-            double value = (double) megatonnesquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
+            return new MassMomentOfInertia(megatonnesquarecentimeters, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareDecimeters(QuantityValue megatonnesquaredecimeters)
+        public static MassMomentOfInertia FromMegatonneSquareDecimeters(double megatonnesquaredecimeters)
         {
-            double value = (double) megatonnesquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
+            return new MassMomentOfInertia(megatonnesquaredecimeters, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareMeters(QuantityValue megatonnesquaremeters)
+        public static MassMomentOfInertia FromMegatonneSquareMeters(double megatonnesquaremeters)
         {
-            double value = (double) megatonnesquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMeter);
+            return new MassMomentOfInertia(megatonnesquaremeters, MassMomentOfInertiaUnit.MegatonneSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareMilimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareMilimeters(QuantityValue megatonnesquaremilimeters)
+        public static MassMomentOfInertia FromMegatonneSquareMilimeters(double megatonnesquaremilimeters)
         {
-            double value = (double) megatonnesquaremilimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
+            return new MassMomentOfInertia(megatonnesquaremilimeters, MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareCentimeters(QuantityValue milligramsquarecentimeters)
+        public static MassMomentOfInertia FromMilligramSquareCentimeters(double milligramsquarecentimeters)
         {
-            double value = (double) milligramsquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
+            return new MassMomentOfInertia(milligramsquarecentimeters, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareDecimeters(QuantityValue milligramsquaredecimeters)
+        public static MassMomentOfInertia FromMilligramSquareDecimeters(double milligramsquaredecimeters)
         {
-            double value = (double) milligramsquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
+            return new MassMomentOfInertia(milligramsquaredecimeters, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareMeters(QuantityValue milligramsquaremeters)
+        public static MassMomentOfInertia FromMilligramSquareMeters(double milligramsquaremeters)
         {
-            double value = (double) milligramsquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMeter);
+            return new MassMomentOfInertia(milligramsquaremeters, MassMomentOfInertiaUnit.MilligramSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareMillimeters(QuantityValue milligramsquaremillimeters)
+        public static MassMomentOfInertia FromMilligramSquareMillimeters(double milligramsquaremillimeters)
         {
-            double value = (double) milligramsquaremillimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
+            return new MassMomentOfInertia(milligramsquaremillimeters, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.PoundSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromPoundSquareFeet(QuantityValue poundsquarefeet)
+        public static MassMomentOfInertia FromPoundSquareFeet(double poundsquarefeet)
         {
-            double value = (double) poundsquarefeet;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareFoot);
+            return new MassMomentOfInertia(poundsquarefeet, MassMomentOfInertiaUnit.PoundSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.PoundSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromPoundSquareInches(QuantityValue poundsquareinches)
+        public static MassMomentOfInertia FromPoundSquareInches(double poundsquareinches)
         {
-            double value = (double) poundsquareinches;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareInch);
+            return new MassMomentOfInertia(poundsquareinches, MassMomentOfInertiaUnit.PoundSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.SlugSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromSlugSquareFeet(QuantityValue slugsquarefeet)
+        public static MassMomentOfInertia FromSlugSquareFeet(double slugsquarefeet)
         {
-            double value = (double) slugsquarefeet;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareFoot);
+            return new MassMomentOfInertia(slugsquarefeet, MassMomentOfInertiaUnit.SlugSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.SlugSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromSlugSquareInches(QuantityValue slugsquareinches)
+        public static MassMomentOfInertia FromSlugSquareInches(double slugsquareinches)
         {
-            double value = (double) slugsquareinches;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareInch);
+            return new MassMomentOfInertia(slugsquareinches, MassMomentOfInertiaUnit.SlugSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareCentimeters(QuantityValue tonnesquarecentimeters)
+        public static MassMomentOfInertia FromTonneSquareCentimeters(double tonnesquarecentimeters)
         {
-            double value = (double) tonnesquarecentimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareCentimeter);
+            return new MassMomentOfInertia(tonnesquarecentimeters, MassMomentOfInertiaUnit.TonneSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareDecimeters(QuantityValue tonnesquaredecimeters)
+        public static MassMomentOfInertia FromTonneSquareDecimeters(double tonnesquaredecimeters)
         {
-            double value = (double) tonnesquaredecimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareDecimeter);
+            return new MassMomentOfInertia(tonnesquaredecimeters, MassMomentOfInertiaUnit.TonneSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareMeters(QuantityValue tonnesquaremeters)
+        public static MassMomentOfInertia FromTonneSquareMeters(double tonnesquaremeters)
         {
-            double value = (double) tonnesquaremeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMeter);
+            return new MassMomentOfInertia(tonnesquaremeters, MassMomentOfInertiaUnit.TonneSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareMilimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareMilimeters(QuantityValue tonnesquaremilimeters)
+        public static MassMomentOfInertia FromTonneSquareMilimeters(double tonnesquaremilimeters)
         {
-            double value = (double) tonnesquaremilimeters;
-            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMilimeter);
+            return new MassMomentOfInertia(tonnesquaremilimeters, MassMomentOfInertiaUnit.TonneSquareMilimeter);
         }
 
         /// <summary>
@@ -719,9 +691,9 @@ public static MassMomentOfInertia FromTonneSquareMilimeters(QuantityValue tonnes
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MassMomentOfInertia unit value.</returns>
-        public static MassMomentOfInertia From(QuantityValue value, MassMomentOfInertiaUnit fromUnit)
+        public static MassMomentOfInertia From(double value, MassMomentOfInertiaUnit fromUnit)
         {
-            return new MassMomentOfInertia((double)value, fromUnit);
+            return new MassMomentOfInertia(value, fromUnit);
         }
 
         #endregion
@@ -1132,15 +1104,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MassMomentOfInertiaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MassMomentOfInertiaUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassMomentOfInertiaUnit)} is supported.", nameof(unit));
@@ -1309,18 +1272,6 @@ public MassMomentOfInertia ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MassMomentOfInertiaUnit> IQuantity<MassMomentOfInertiaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MassMomentOfInertiaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MassMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Molality.g.cs b/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
index 6bc27c5f39..da1b9a2d1b 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Molality :
-        IArithmeticQuantity<Molality, MolalityUnit, double>,
+        IArithmeticQuantity<Molality, MolalityUnit>,
         IComparable,
         IComparable<Molality>,
         IConvertible,
@@ -151,7 +151,7 @@ public Molality(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -232,20 +232,18 @@ public static string GetAbbreviation(MolalityUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MolePerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molality FromMolesPerGram(QuantityValue molespergram)
+        public static Molality FromMolesPerGram(double molespergram)
         {
-            double value = (double) molespergram;
-            return new Molality(value, MolalityUnit.MolePerGram);
+            return new Molality(molespergram, MolalityUnit.MolePerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MolePerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molality FromMolesPerKilogram(QuantityValue molesperkilogram)
+        public static Molality FromMolesPerKilogram(double molesperkilogram)
         {
-            double value = (double) molesperkilogram;
-            return new Molality(value, MolalityUnit.MolePerKilogram);
+            return new Molality(molesperkilogram, MolalityUnit.MolePerKilogram);
         }
 
         /// <summary>
@@ -254,9 +252,9 @@ public static Molality FromMolesPerKilogram(QuantityValue molesperkilogram)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Molality unit value.</returns>
-        public static Molality From(QuantityValue value, MolalityUnit fromUnit)
+        public static Molality From(double value, MolalityUnit fromUnit)
         {
-            return new Molality((double)value, fromUnit);
+            return new Molality(value, fromUnit);
         }
 
         #endregion
@@ -667,15 +665,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MolalityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolalityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MolalityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolalityUnit)} is supported.", nameof(unit));
@@ -792,18 +781,6 @@ public Molality ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolalityUnit> IQuantity<MolalityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MolalityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolalityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
index 2685cba4e5..bfba26db00 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct MolarEnergy :
-        IArithmeticQuantity<MolarEnergy, MolarEnergyUnit, double>,
+        IArithmeticQuantity<MolarEnergy, MolarEnergyUnit>,
         IComparable,
         IComparable<MolarEnergy>,
         IConvertible,
@@ -149,7 +149,7 @@ public MolarEnergy(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -237,30 +237,27 @@ public static string GetAbbreviation(MolarEnergyUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.JoulePerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromJoulesPerMole(QuantityValue joulespermole)
+        public static MolarEnergy FromJoulesPerMole(double joulespermole)
         {
-            double value = (double) joulespermole;
-            return new MolarEnergy(value, MolarEnergyUnit.JoulePerMole);
+            return new MolarEnergy(joulespermole, MolarEnergyUnit.JoulePerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.KilojoulePerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromKilojoulesPerMole(QuantityValue kilojoulespermole)
+        public static MolarEnergy FromKilojoulesPerMole(double kilojoulespermole)
         {
-            double value = (double) kilojoulespermole;
-            return new MolarEnergy(value, MolarEnergyUnit.KilojoulePerMole);
+            return new MolarEnergy(kilojoulespermole, MolarEnergyUnit.KilojoulePerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.MegajoulePerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromMegajoulesPerMole(QuantityValue megajoulespermole)
+        public static MolarEnergy FromMegajoulesPerMole(double megajoulespermole)
         {
-            double value = (double) megajoulespermole;
-            return new MolarEnergy(value, MolarEnergyUnit.MegajoulePerMole);
+            return new MolarEnergy(megajoulespermole, MolarEnergyUnit.MegajoulePerMole);
         }
 
         /// <summary>
@@ -269,9 +266,9 @@ public static MolarEnergy FromMegajoulesPerMole(QuantityValue megajoulespermole)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MolarEnergy unit value.</returns>
-        public static MolarEnergy From(QuantityValue value, MolarEnergyUnit fromUnit)
+        public static MolarEnergy From(double value, MolarEnergyUnit fromUnit)
         {
-            return new MolarEnergy((double)value, fromUnit);
+            return new MolarEnergy(value, fromUnit);
         }
 
         #endregion
@@ -682,15 +679,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MolarEnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEnergyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MolarEnergyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEnergyUnit)} is supported.", nameof(unit));
@@ -809,18 +797,6 @@ public MolarEnergy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarEnergyUnit> IQuantity<MolarEnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MolarEnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
index c7006545cc..b03a52aa8b 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct MolarEntropy :
-        IArithmeticQuantity<MolarEntropy, MolarEntropyUnit, double>,
+        IArithmeticQuantity<MolarEntropy, MolarEntropyUnit>,
         IComparable,
         IComparable<MolarEntropy>,
         IConvertible,
@@ -149,7 +149,7 @@ public MolarEntropy(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -237,30 +237,27 @@ public static string GetAbbreviation(MolarEntropyUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.JoulePerMoleKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromJoulesPerMoleKelvin(QuantityValue joulespermolekelvin)
+        public static MolarEntropy FromJoulesPerMoleKelvin(double joulespermolekelvin)
         {
-            double value = (double) joulespermolekelvin;
-            return new MolarEntropy(value, MolarEntropyUnit.JoulePerMoleKelvin);
+            return new MolarEntropy(joulespermolekelvin, MolarEntropyUnit.JoulePerMoleKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.KilojoulePerMoleKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromKilojoulesPerMoleKelvin(QuantityValue kilojoulespermolekelvin)
+        public static MolarEntropy FromKilojoulesPerMoleKelvin(double kilojoulespermolekelvin)
         {
-            double value = (double) kilojoulespermolekelvin;
-            return new MolarEntropy(value, MolarEntropyUnit.KilojoulePerMoleKelvin);
+            return new MolarEntropy(kilojoulespermolekelvin, MolarEntropyUnit.KilojoulePerMoleKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.MegajoulePerMoleKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromMegajoulesPerMoleKelvin(QuantityValue megajoulespermolekelvin)
+        public static MolarEntropy FromMegajoulesPerMoleKelvin(double megajoulespermolekelvin)
         {
-            double value = (double) megajoulespermolekelvin;
-            return new MolarEntropy(value, MolarEntropyUnit.MegajoulePerMoleKelvin);
+            return new MolarEntropy(megajoulespermolekelvin, MolarEntropyUnit.MegajoulePerMoleKelvin);
         }
 
         /// <summary>
@@ -269,9 +266,9 @@ public static MolarEntropy FromMegajoulesPerMoleKelvin(QuantityValue megajoulesp
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MolarEntropy unit value.</returns>
-        public static MolarEntropy From(QuantityValue value, MolarEntropyUnit fromUnit)
+        public static MolarEntropy From(double value, MolarEntropyUnit fromUnit)
         {
-            return new MolarEntropy((double)value, fromUnit);
+            return new MolarEntropy(value, fromUnit);
         }
 
         #endregion
@@ -682,15 +679,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MolarEntropyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEntropyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MolarEntropyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEntropyUnit)} is supported.", nameof(unit));
@@ -809,18 +797,6 @@ public MolarEntropy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarEntropyUnit> IQuantity<MolarEntropyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MolarEntropyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarEntropyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
index c9bd4c5d32..0dd64967c2 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct MolarFlow :
-        IArithmeticQuantity<MolarFlow, MolarFlowUnit, double>,
+        IArithmeticQuantity<MolarFlow, MolarFlowUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<MolarFlow, Duration, AmountOfSubstance>,
         IMultiplyOperators<MolarFlow, TimeSpan, AmountOfSubstance>,
@@ -164,7 +164,7 @@ public MolarFlow(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -294,90 +294,81 @@ public static string GetAbbreviation(MolarFlowUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromKilomolesPerHour(QuantityValue kilomolesperhour)
+        public static MolarFlow FromKilomolesPerHour(double kilomolesperhour)
         {
-            double value = (double) kilomolesperhour;
-            return new MolarFlow(value, MolarFlowUnit.KilomolePerHour);
+            return new MolarFlow(kilomolesperhour, MolarFlowUnit.KilomolePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromKilomolesPerMinute(QuantityValue kilomolesperminute)
+        public static MolarFlow FromKilomolesPerMinute(double kilomolesperminute)
         {
-            double value = (double) kilomolesperminute;
-            return new MolarFlow(value, MolarFlowUnit.KilomolePerMinute);
+            return new MolarFlow(kilomolesperminute, MolarFlowUnit.KilomolePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromKilomolesPerSecond(QuantityValue kilomolespersecond)
+        public static MolarFlow FromKilomolesPerSecond(double kilomolespersecond)
         {
-            double value = (double) kilomolespersecond;
-            return new MolarFlow(value, MolarFlowUnit.KilomolePerSecond);
+            return new MolarFlow(kilomolespersecond, MolarFlowUnit.KilomolePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromMolesPerHour(QuantityValue molesperhour)
+        public static MolarFlow FromMolesPerHour(double molesperhour)
         {
-            double value = (double) molesperhour;
-            return new MolarFlow(value, MolarFlowUnit.MolePerHour);
+            return new MolarFlow(molesperhour, MolarFlowUnit.MolePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromMolesPerMinute(QuantityValue molesperminute)
+        public static MolarFlow FromMolesPerMinute(double molesperminute)
         {
-            double value = (double) molesperminute;
-            return new MolarFlow(value, MolarFlowUnit.MolePerMinute);
+            return new MolarFlow(molesperminute, MolarFlowUnit.MolePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromMolesPerSecond(QuantityValue molespersecond)
+        public static MolarFlow FromMolesPerSecond(double molespersecond)
         {
-            double value = (double) molespersecond;
-            return new MolarFlow(value, MolarFlowUnit.MolePerSecond);
+            return new MolarFlow(molespersecond, MolarFlowUnit.MolePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromPoundMolesPerHour(QuantityValue poundmolesperhour)
+        public static MolarFlow FromPoundMolesPerHour(double poundmolesperhour)
         {
-            double value = (double) poundmolesperhour;
-            return new MolarFlow(value, MolarFlowUnit.PoundMolePerHour);
+            return new MolarFlow(poundmolesperhour, MolarFlowUnit.PoundMolePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromPoundMolesPerMinute(QuantityValue poundmolesperminute)
+        public static MolarFlow FromPoundMolesPerMinute(double poundmolesperminute)
         {
-            double value = (double) poundmolesperminute;
-            return new MolarFlow(value, MolarFlowUnit.PoundMolePerMinute);
+            return new MolarFlow(poundmolesperminute, MolarFlowUnit.PoundMolePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromPoundMolesPerSecond(QuantityValue poundmolespersecond)
+        public static MolarFlow FromPoundMolesPerSecond(double poundmolespersecond)
         {
-            double value = (double) poundmolespersecond;
-            return new MolarFlow(value, MolarFlowUnit.PoundMolePerSecond);
+            return new MolarFlow(poundmolespersecond, MolarFlowUnit.PoundMolePerSecond);
         }
 
         /// <summary>
@@ -386,9 +377,9 @@ public static MolarFlow FromPoundMolesPerSecond(QuantityValue poundmolespersecon
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MolarFlow unit value.</returns>
-        public static MolarFlow From(QuantityValue value, MolarFlowUnit fromUnit)
+        public static MolarFlow From(double value, MolarFlowUnit fromUnit)
         {
-            return new MolarFlow((double)value, fromUnit);
+            return new MolarFlow(value, fromUnit);
         }
 
         #endregion
@@ -833,15 +824,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MolarFlowUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarFlowUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MolarFlowUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarFlowUnit)} is supported.", nameof(unit));
@@ -972,18 +954,6 @@ public MolarFlow ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarFlowUnit> IQuantity<MolarFlowUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MolarFlowUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarFlowUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
index 435d364984..3bfbb57fd7 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct MolarMass :
-        IArithmeticQuantity<MolarMass, MolarMassUnit, double>,
+        IArithmeticQuantity<MolarMass, MolarMassUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<MolarMass, AmountOfSubstance, Mass>,
         IMultiplyOperators<MolarMass, Molarity, MassConcentration>,
@@ -167,7 +167,7 @@ public MolarMass(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -325,130 +325,117 @@ public static string GetAbbreviation(MolarMassUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.CentigramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromCentigramsPerMole(QuantityValue centigramspermole)
+        public static MolarMass FromCentigramsPerMole(double centigramspermole)
         {
-            double value = (double) centigramspermole;
-            return new MolarMass(value, MolarMassUnit.CentigramPerMole);
+            return new MolarMass(centigramspermole, MolarMassUnit.CentigramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.DecagramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromDecagramsPerMole(QuantityValue decagramspermole)
+        public static MolarMass FromDecagramsPerMole(double decagramspermole)
         {
-            double value = (double) decagramspermole;
-            return new MolarMass(value, MolarMassUnit.DecagramPerMole);
+            return new MolarMass(decagramspermole, MolarMassUnit.DecagramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.DecigramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromDecigramsPerMole(QuantityValue decigramspermole)
+        public static MolarMass FromDecigramsPerMole(double decigramspermole)
         {
-            double value = (double) decigramspermole;
-            return new MolarMass(value, MolarMassUnit.DecigramPerMole);
+            return new MolarMass(decigramspermole, MolarMassUnit.DecigramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.GramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromGramsPerMole(QuantityValue gramspermole)
+        public static MolarMass FromGramsPerMole(double gramspermole)
         {
-            double value = (double) gramspermole;
-            return new MolarMass(value, MolarMassUnit.GramPerMole);
+            return new MolarMass(gramspermole, MolarMassUnit.GramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.HectogramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromHectogramsPerMole(QuantityValue hectogramspermole)
+        public static MolarMass FromHectogramsPerMole(double hectogramspermole)
         {
-            double value = (double) hectogramspermole;
-            return new MolarMass(value, MolarMassUnit.HectogramPerMole);
+            return new MolarMass(hectogramspermole, MolarMassUnit.HectogramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilogramPerKilomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromKilogramsPerKilomole(QuantityValue kilogramsperkilomole)
+        public static MolarMass FromKilogramsPerKilomole(double kilogramsperkilomole)
         {
-            double value = (double) kilogramsperkilomole;
-            return new MolarMass(value, MolarMassUnit.KilogramPerKilomole);
+            return new MolarMass(kilogramsperkilomole, MolarMassUnit.KilogramPerKilomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilogramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromKilogramsPerMole(QuantityValue kilogramspermole)
+        public static MolarMass FromKilogramsPerMole(double kilogramspermole)
         {
-            double value = (double) kilogramspermole;
-            return new MolarMass(value, MolarMassUnit.KilogramPerMole);
+            return new MolarMass(kilogramspermole, MolarMassUnit.KilogramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilopoundPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromKilopoundsPerMole(QuantityValue kilopoundspermole)
+        public static MolarMass FromKilopoundsPerMole(double kilopoundspermole)
         {
-            double value = (double) kilopoundspermole;
-            return new MolarMass(value, MolarMassUnit.KilopoundPerMole);
+            return new MolarMass(kilopoundspermole, MolarMassUnit.KilopoundPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MegapoundPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMegapoundsPerMole(QuantityValue megapoundspermole)
+        public static MolarMass FromMegapoundsPerMole(double megapoundspermole)
         {
-            double value = (double) megapoundspermole;
-            return new MolarMass(value, MolarMassUnit.MegapoundPerMole);
+            return new MolarMass(megapoundspermole, MolarMassUnit.MegapoundPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MicrogramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMicrogramsPerMole(QuantityValue microgramspermole)
+        public static MolarMass FromMicrogramsPerMole(double microgramspermole)
         {
-            double value = (double) microgramspermole;
-            return new MolarMass(value, MolarMassUnit.MicrogramPerMole);
+            return new MolarMass(microgramspermole, MolarMassUnit.MicrogramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MilligramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMilligramsPerMole(QuantityValue milligramspermole)
+        public static MolarMass FromMilligramsPerMole(double milligramspermole)
         {
-            double value = (double) milligramspermole;
-            return new MolarMass(value, MolarMassUnit.MilligramPerMole);
+            return new MolarMass(milligramspermole, MolarMassUnit.MilligramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.NanogramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromNanogramsPerMole(QuantityValue nanogramspermole)
+        public static MolarMass FromNanogramsPerMole(double nanogramspermole)
         {
-            double value = (double) nanogramspermole;
-            return new MolarMass(value, MolarMassUnit.NanogramPerMole);
+            return new MolarMass(nanogramspermole, MolarMassUnit.NanogramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.PoundPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromPoundsPerMole(QuantityValue poundspermole)
+        public static MolarMass FromPoundsPerMole(double poundspermole)
         {
-            double value = (double) poundspermole;
-            return new MolarMass(value, MolarMassUnit.PoundPerMole);
+            return new MolarMass(poundspermole, MolarMassUnit.PoundPerMole);
         }
 
         /// <summary>
@@ -457,9 +444,9 @@ public static MolarMass FromPoundsPerMole(QuantityValue poundspermole)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>MolarMass unit value.</returns>
-        public static MolarMass From(QuantityValue value, MolarMassUnit fromUnit)
+        public static MolarMass From(double value, MolarMassUnit fromUnit)
         {
-            return new MolarMass((double)value, fromUnit);
+            return new MolarMass(value, fromUnit);
         }
 
         #endregion
@@ -892,15 +879,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MolarMassUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarMassUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MolarMassUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarMassUnit)} is supported.", nameof(unit));
@@ -1039,18 +1017,6 @@ public MolarMass ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarMassUnit> IQuantity<MolarMassUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MolarMassUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarMassUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
index 936248d156..65c56868a3 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Molarity :
-        IArithmeticQuantity<Molarity, MolarityUnit, double>,
+        IArithmeticQuantity<Molarity, MolarityUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Molarity, MolarMass, MassConcentration>,
         IMultiplyOperators<Molarity, VolumeConcentration, Molarity>,
@@ -167,7 +167,7 @@ public Molarity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -311,110 +311,99 @@ public static string GetAbbreviation(MolarityUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.CentimolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromCentimolesPerLiter(QuantityValue centimolesperliter)
+        public static Molarity FromCentimolesPerLiter(double centimolesperliter)
         {
-            double value = (double) centimolesperliter;
-            return new Molarity(value, MolarityUnit.CentimolePerLiter);
+            return new Molarity(centimolesperliter, MolarityUnit.CentimolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.DecimolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromDecimolesPerLiter(QuantityValue decimolesperliter)
+        public static Molarity FromDecimolesPerLiter(double decimolesperliter)
         {
-            double value = (double) decimolesperliter;
-            return new Molarity(value, MolarityUnit.DecimolePerLiter);
+            return new Molarity(decimolesperliter, MolarityUnit.DecimolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.FemtomolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromFemtomolesPerLiter(QuantityValue femtomolesperliter)
+        public static Molarity FromFemtomolesPerLiter(double femtomolesperliter)
         {
-            double value = (double) femtomolesperliter;
-            return new Molarity(value, MolarityUnit.FemtomolePerLiter);
+            return new Molarity(femtomolesperliter, MolarityUnit.FemtomolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.KilomolePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromKilomolesPerCubicMeter(QuantityValue kilomolespercubicmeter)
+        public static Molarity FromKilomolesPerCubicMeter(double kilomolespercubicmeter)
         {
-            double value = (double) kilomolespercubicmeter;
-            return new Molarity(value, MolarityUnit.KilomolePerCubicMeter);
+            return new Molarity(kilomolespercubicmeter, MolarityUnit.KilomolePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MicromolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMicromolesPerLiter(QuantityValue micromolesperliter)
+        public static Molarity FromMicromolesPerLiter(double micromolesperliter)
         {
-            double value = (double) micromolesperliter;
-            return new Molarity(value, MolarityUnit.MicromolePerLiter);
+            return new Molarity(micromolesperliter, MolarityUnit.MicromolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MillimolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMillimolesPerLiter(QuantityValue millimolesperliter)
+        public static Molarity FromMillimolesPerLiter(double millimolesperliter)
         {
-            double value = (double) millimolesperliter;
-            return new Molarity(value, MolarityUnit.MillimolePerLiter);
+            return new Molarity(millimolesperliter, MolarityUnit.MillimolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MolePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMolesPerCubicMeter(QuantityValue molespercubicmeter)
+        public static Molarity FromMolesPerCubicMeter(double molespercubicmeter)
         {
-            double value = (double) molespercubicmeter;
-            return new Molarity(value, MolarityUnit.MolePerCubicMeter);
+            return new Molarity(molespercubicmeter, MolarityUnit.MolePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMolesPerLiter(QuantityValue molesperliter)
+        public static Molarity FromMolesPerLiter(double molesperliter)
         {
-            double value = (double) molesperliter;
-            return new Molarity(value, MolarityUnit.MolePerLiter);
+            return new Molarity(molesperliter, MolarityUnit.MolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.NanomolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromNanomolesPerLiter(QuantityValue nanomolesperliter)
+        public static Molarity FromNanomolesPerLiter(double nanomolesperliter)
         {
-            double value = (double) nanomolesperliter;
-            return new Molarity(value, MolarityUnit.NanomolePerLiter);
+            return new Molarity(nanomolesperliter, MolarityUnit.NanomolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.PicomolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromPicomolesPerLiter(QuantityValue picomolesperliter)
+        public static Molarity FromPicomolesPerLiter(double picomolesperliter)
         {
-            double value = (double) picomolesperliter;
-            return new Molarity(value, MolarityUnit.PicomolePerLiter);
+            return new Molarity(picomolesperliter, MolarityUnit.PicomolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.PoundMolePerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromPoundMolesPerCubicFoot(QuantityValue poundmolespercubicfoot)
+        public static Molarity FromPoundMolesPerCubicFoot(double poundmolespercubicfoot)
         {
-            double value = (double) poundmolespercubicfoot;
-            return new Molarity(value, MolarityUnit.PoundMolePerCubicFoot);
+            return new Molarity(poundmolespercubicfoot, MolarityUnit.PoundMolePerCubicFoot);
         }
 
         /// <summary>
@@ -423,9 +412,9 @@ public static Molarity FromPoundMolesPerCubicFoot(QuantityValue poundmolespercub
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Molarity unit value.</returns>
-        public static Molarity From(QuantityValue value, MolarityUnit fromUnit)
+        public static Molarity From(double value, MolarityUnit fromUnit)
         {
-            return new Molarity((double)value, fromUnit);
+            return new Molarity(value, fromUnit);
         }
 
         #endregion
@@ -852,15 +841,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is MolarityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is MolarityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarityUnit)} is supported.", nameof(unit));
@@ -995,18 +975,6 @@ public Molarity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<MolarityUnit> IQuantity<MolarityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not MolarityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(MolarityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
index be2971b0cd..127dee07c2 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Permeability :
-        IArithmeticQuantity<Permeability, PermeabilityUnit, double>,
+        IArithmeticQuantity<Permeability, PermeabilityUnit>,
         IComparable,
         IComparable<Permeability>,
         IConvertible,
@@ -150,7 +150,7 @@ public Permeability(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(PermeabilityUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="Permeability"/> from <see cref="PermeabilityUnit.HenryPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Permeability FromHenriesPerMeter(QuantityValue henriespermeter)
+        public static Permeability FromHenriesPerMeter(double henriespermeter)
         {
-            double value = (double) henriespermeter;
-            return new Permeability(value, PermeabilityUnit.HenryPerMeter);
+            return new Permeability(henriespermeter, PermeabilityUnit.HenryPerMeter);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static Permeability FromHenriesPerMeter(QuantityValue henriespermeter)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Permeability unit value.</returns>
-        public static Permeability From(QuantityValue value, PermeabilityUnit fromUnit)
+        public static Permeability From(double value, PermeabilityUnit fromUnit)
         {
-            return new Permeability((double)value, fromUnit);
+            return new Permeability(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is PermeabilityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermeabilityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is PermeabilityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermeabilityUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public Permeability ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PermeabilityUnit> IQuantity<PermeabilityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not PermeabilityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermeabilityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
index ef68870bba..0695207fde 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Permittivity :
-        IArithmeticQuantity<Permittivity, PermittivityUnit, double>,
+        IArithmeticQuantity<Permittivity, PermittivityUnit>,
         IComparable,
         IComparable<Permittivity>,
         IConvertible,
@@ -150,7 +150,7 @@ public Permittivity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(PermittivityUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="Permittivity"/> from <see cref="PermittivityUnit.FaradPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Permittivity FromFaradsPerMeter(QuantityValue faradspermeter)
+        public static Permittivity FromFaradsPerMeter(double faradspermeter)
         {
-            double value = (double) faradspermeter;
-            return new Permittivity(value, PermittivityUnit.FaradPerMeter);
+            return new Permittivity(faradspermeter, PermittivityUnit.FaradPerMeter);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static Permittivity FromFaradsPerMeter(QuantityValue faradspermeter)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Permittivity unit value.</returns>
-        public static Permittivity From(QuantityValue value, PermittivityUnit fromUnit)
+        public static Permittivity From(double value, PermittivityUnit fromUnit)
         {
-            return new Permittivity((double)value, fromUnit);
+            return new Permittivity(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is PermittivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermittivityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is PermittivityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermittivityUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public Permittivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PermittivityUnit> IQuantity<PermittivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not PermittivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PermittivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs b/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
index a2443d796f..797b6278c8 100644
--- a/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct PorousMediumPermeability :
-        IArithmeticQuantity<PorousMediumPermeability, PorousMediumPermeabilityUnit, double>,
+        IArithmeticQuantity<PorousMediumPermeability, PorousMediumPermeabilityUnit>,
         IComparable,
         IComparable<PorousMediumPermeability>,
         IConvertible,
@@ -154,7 +154,7 @@ public PorousMediumPermeability(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -256,50 +256,45 @@ public static string GetAbbreviation(PorousMediumPermeabilityUnit unit, IFormatP
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Darcy"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromDarcys(QuantityValue darcys)
+        public static PorousMediumPermeability FromDarcys(double darcys)
         {
-            double value = (double) darcys;
-            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Darcy);
+            return new PorousMediumPermeability(darcys, PorousMediumPermeabilityUnit.Darcy);
         }
 
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Microdarcy"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromMicrodarcys(QuantityValue microdarcys)
+        public static PorousMediumPermeability FromMicrodarcys(double microdarcys)
         {
-            double value = (double) microdarcys;
-            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Microdarcy);
+            return new PorousMediumPermeability(microdarcys, PorousMediumPermeabilityUnit.Microdarcy);
         }
 
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Millidarcy"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromMillidarcys(QuantityValue millidarcys)
+        public static PorousMediumPermeability FromMillidarcys(double millidarcys)
         {
-            double value = (double) millidarcys;
-            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Millidarcy);
+            return new PorousMediumPermeability(millidarcys, PorousMediumPermeabilityUnit.Millidarcy);
         }
 
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.SquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromSquareCentimeters(QuantityValue squarecentimeters)
+        public static PorousMediumPermeability FromSquareCentimeters(double squarecentimeters)
         {
-            double value = (double) squarecentimeters;
-            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.SquareCentimeter);
+            return new PorousMediumPermeability(squarecentimeters, PorousMediumPermeabilityUnit.SquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.SquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromSquareMeters(QuantityValue squaremeters)
+        public static PorousMediumPermeability FromSquareMeters(double squaremeters)
         {
-            double value = (double) squaremeters;
-            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.SquareMeter);
+            return new PorousMediumPermeability(squaremeters, PorousMediumPermeabilityUnit.SquareMeter);
         }
 
         /// <summary>
@@ -308,9 +303,9 @@ public static PorousMediumPermeability FromSquareMeters(QuantityValue squaremete
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>PorousMediumPermeability unit value.</returns>
-        public static PorousMediumPermeability From(QuantityValue value, PorousMediumPermeabilityUnit fromUnit)
+        public static PorousMediumPermeability From(double value, PorousMediumPermeabilityUnit fromUnit)
         {
-            return new PorousMediumPermeability((double)value, fromUnit);
+            return new PorousMediumPermeability(value, fromUnit);
         }
 
         #endregion
@@ -721,15 +716,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is PorousMediumPermeabilityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PorousMediumPermeabilityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is PorousMediumPermeabilityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PorousMediumPermeabilityUnit)} is supported.", nameof(unit));
@@ -852,18 +838,6 @@ public PorousMediumPermeability ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PorousMediumPermeabilityUnit> IQuantity<PorousMediumPermeabilityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not PorousMediumPermeabilityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PorousMediumPermeabilityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
index cfd9e0cf5d..aea66bf0d1 100644
--- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Power :
-        IArithmeticQuantity<Power, PowerUnit, double>,
+        IArithmeticQuantity<Power, PowerUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Power, HeatFlux, Area>,
         IDivisionOperators<Power, ElectricPotential, ElectricCurrent>,
@@ -189,7 +189,7 @@ public Power(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -438,260 +438,234 @@ public static string GetAbbreviation(PowerUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.BoilerHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromBoilerHorsepower(QuantityValue boilerhorsepower)
+        public static Power FromBoilerHorsepower(double boilerhorsepower)
         {
-            double value = (double) boilerhorsepower;
-            return new Power(value, PowerUnit.BoilerHorsepower);
+            return new Power(boilerhorsepower, PowerUnit.BoilerHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.BritishThermalUnitPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromBritishThermalUnitsPerHour(QuantityValue britishthermalunitsperhour)
+        public static Power FromBritishThermalUnitsPerHour(double britishthermalunitsperhour)
         {
-            double value = (double) britishthermalunitsperhour;
-            return new Power(value, PowerUnit.BritishThermalUnitPerHour);
+            return new Power(britishthermalunitsperhour, PowerUnit.BritishThermalUnitPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Decawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromDecawatts(QuantityValue decawatts)
+        public static Power FromDecawatts(double decawatts)
         {
-            double value = (double) decawatts;
-            return new Power(value, PowerUnit.Decawatt);
+            return new Power(decawatts, PowerUnit.Decawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Deciwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromDeciwatts(QuantityValue deciwatts)
+        public static Power FromDeciwatts(double deciwatts)
         {
-            double value = (double) deciwatts;
-            return new Power(value, PowerUnit.Deciwatt);
+            return new Power(deciwatts, PowerUnit.Deciwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.ElectricalHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromElectricalHorsepower(QuantityValue electricalhorsepower)
+        public static Power FromElectricalHorsepower(double electricalhorsepower)
         {
-            double value = (double) electricalhorsepower;
-            return new Power(value, PowerUnit.ElectricalHorsepower);
+            return new Power(electricalhorsepower, PowerUnit.ElectricalHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Femtowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromFemtowatts(QuantityValue femtowatts)
+        public static Power FromFemtowatts(double femtowatts)
         {
-            double value = (double) femtowatts;
-            return new Power(value, PowerUnit.Femtowatt);
+            return new Power(femtowatts, PowerUnit.Femtowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.GigajoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromGigajoulesPerHour(QuantityValue gigajoulesperhour)
+        public static Power FromGigajoulesPerHour(double gigajoulesperhour)
         {
-            double value = (double) gigajoulesperhour;
-            return new Power(value, PowerUnit.GigajoulePerHour);
+            return new Power(gigajoulesperhour, PowerUnit.GigajoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Gigawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromGigawatts(QuantityValue gigawatts)
+        public static Power FromGigawatts(double gigawatts)
         {
-            double value = (double) gigawatts;
-            return new Power(value, PowerUnit.Gigawatt);
+            return new Power(gigawatts, PowerUnit.Gigawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.HydraulicHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromHydraulicHorsepower(QuantityValue hydraulichorsepower)
+        public static Power FromHydraulicHorsepower(double hydraulichorsepower)
         {
-            double value = (double) hydraulichorsepower;
-            return new Power(value, PowerUnit.HydraulicHorsepower);
+            return new Power(hydraulichorsepower, PowerUnit.HydraulicHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.JoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromJoulesPerHour(QuantityValue joulesperhour)
+        public static Power FromJoulesPerHour(double joulesperhour)
         {
-            double value = (double) joulesperhour;
-            return new Power(value, PowerUnit.JoulePerHour);
+            return new Power(joulesperhour, PowerUnit.JoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.KilobritishThermalUnitPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilobritishThermalUnitsPerHour(QuantityValue kilobritishthermalunitsperhour)
+        public static Power FromKilobritishThermalUnitsPerHour(double kilobritishthermalunitsperhour)
         {
-            double value = (double) kilobritishthermalunitsperhour;
-            return new Power(value, PowerUnit.KilobritishThermalUnitPerHour);
+            return new Power(kilobritishthermalunitsperhour, PowerUnit.KilobritishThermalUnitPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.KilojoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilojoulesPerHour(QuantityValue kilojoulesperhour)
+        public static Power FromKilojoulesPerHour(double kilojoulesperhour)
         {
-            double value = (double) kilojoulesperhour;
-            return new Power(value, PowerUnit.KilojoulePerHour);
+            return new Power(kilojoulesperhour, PowerUnit.KilojoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Kilowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilowatts(QuantityValue kilowatts)
+        public static Power FromKilowatts(double kilowatts)
         {
-            double value = (double) kilowatts;
-            return new Power(value, PowerUnit.Kilowatt);
+            return new Power(kilowatts, PowerUnit.Kilowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MechanicalHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMechanicalHorsepower(QuantityValue mechanicalhorsepower)
+        public static Power FromMechanicalHorsepower(double mechanicalhorsepower)
         {
-            double value = (double) mechanicalhorsepower;
-            return new Power(value, PowerUnit.MechanicalHorsepower);
+            return new Power(mechanicalhorsepower, PowerUnit.MechanicalHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MegabritishThermalUnitPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMegabritishThermalUnitsPerHour(QuantityValue megabritishthermalunitsperhour)
+        public static Power FromMegabritishThermalUnitsPerHour(double megabritishthermalunitsperhour)
         {
-            double value = (double) megabritishthermalunitsperhour;
-            return new Power(value, PowerUnit.MegabritishThermalUnitPerHour);
+            return new Power(megabritishthermalunitsperhour, PowerUnit.MegabritishThermalUnitPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MegajoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMegajoulesPerHour(QuantityValue megajoulesperhour)
+        public static Power FromMegajoulesPerHour(double megajoulesperhour)
         {
-            double value = (double) megajoulesperhour;
-            return new Power(value, PowerUnit.MegajoulePerHour);
+            return new Power(megajoulesperhour, PowerUnit.MegajoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Megawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMegawatts(QuantityValue megawatts)
+        public static Power FromMegawatts(double megawatts)
         {
-            double value = (double) megawatts;
-            return new Power(value, PowerUnit.Megawatt);
+            return new Power(megawatts, PowerUnit.Megawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MetricHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMetricHorsepower(QuantityValue metrichorsepower)
+        public static Power FromMetricHorsepower(double metrichorsepower)
         {
-            double value = (double) metrichorsepower;
-            return new Power(value, PowerUnit.MetricHorsepower);
+            return new Power(metrichorsepower, PowerUnit.MetricHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Microwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMicrowatts(QuantityValue microwatts)
+        public static Power FromMicrowatts(double microwatts)
         {
-            double value = (double) microwatts;
-            return new Power(value, PowerUnit.Microwatt);
+            return new Power(microwatts, PowerUnit.Microwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MillijoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMillijoulesPerHour(QuantityValue millijoulesperhour)
+        public static Power FromMillijoulesPerHour(double millijoulesperhour)
         {
-            double value = (double) millijoulesperhour;
-            return new Power(value, PowerUnit.MillijoulePerHour);
+            return new Power(millijoulesperhour, PowerUnit.MillijoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Milliwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMilliwatts(QuantityValue milliwatts)
+        public static Power FromMilliwatts(double milliwatts)
         {
-            double value = (double) milliwatts;
-            return new Power(value, PowerUnit.Milliwatt);
+            return new Power(milliwatts, PowerUnit.Milliwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Nanowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromNanowatts(QuantityValue nanowatts)
+        public static Power FromNanowatts(double nanowatts)
         {
-            double value = (double) nanowatts;
-            return new Power(value, PowerUnit.Nanowatt);
+            return new Power(nanowatts, PowerUnit.Nanowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Petawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromPetawatts(QuantityValue petawatts)
+        public static Power FromPetawatts(double petawatts)
         {
-            double value = (double) petawatts;
-            return new Power(value, PowerUnit.Petawatt);
+            return new Power(petawatts, PowerUnit.Petawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Picowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromPicowatts(QuantityValue picowatts)
+        public static Power FromPicowatts(double picowatts)
         {
-            double value = (double) picowatts;
-            return new Power(value, PowerUnit.Picowatt);
+            return new Power(picowatts, PowerUnit.Picowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Terawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromTerawatts(QuantityValue terawatts)
+        public static Power FromTerawatts(double terawatts)
         {
-            double value = (double) terawatts;
-            return new Power(value, PowerUnit.Terawatt);
+            return new Power(terawatts, PowerUnit.Terawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Watt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromWatts(QuantityValue watts)
+        public static Power FromWatts(double watts)
         {
-            double value = (double) watts;
-            return new Power(value, PowerUnit.Watt);
+            return new Power(watts, PowerUnit.Watt);
         }
 
         /// <summary>
@@ -700,9 +674,9 @@ public static Power FromWatts(QuantityValue watts)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Power unit value.</returns>
-        public static Power From(QuantityValue value, PowerUnit fromUnit)
+        public static Power From(double value, PowerUnit fromUnit)
         {
-            return new Power((double)value, fromUnit);
+            return new Power(value, fromUnit);
         }
 
         #endregion
@@ -1195,15 +1169,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is PowerUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is PowerUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerUnit)} is supported.", nameof(unit));
@@ -1368,18 +1333,6 @@ public Power ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PowerUnit> IQuantity<PowerUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not PowerUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
index 3324bdaf78..22731dc022 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct PowerDensity :
-        IArithmeticQuantity<PowerDensity, PowerDensityUnit, double>,
+        IArithmeticQuantity<PowerDensity, PowerDensityUnit>,
         IComparable,
         IComparable<PowerDensity>,
         IConvertible,
@@ -190,7 +190,7 @@ public PowerDensity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -565,440 +565,396 @@ public static string GetAbbreviation(PowerDensityUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicFoot(QuantityValue decawattspercubicfoot)
+        public static PowerDensity FromDecawattsPerCubicFoot(double decawattspercubicfoot)
         {
-            double value = (double) decawattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicFoot);
+            return new PowerDensity(decawattspercubicfoot, PowerDensityUnit.DecawattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicInch(QuantityValue decawattspercubicinch)
+        public static PowerDensity FromDecawattsPerCubicInch(double decawattspercubicinch)
         {
-            double value = (double) decawattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicInch);
+            return new PowerDensity(decawattspercubicinch, PowerDensityUnit.DecawattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicMeter(QuantityValue decawattspercubicmeter)
+        public static PowerDensity FromDecawattsPerCubicMeter(double decawattspercubicmeter)
         {
-            double value = (double) decawattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicMeter);
+            return new PowerDensity(decawattspercubicmeter, PowerDensityUnit.DecawattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerLiter(QuantityValue decawattsperliter)
+        public static PowerDensity FromDecawattsPerLiter(double decawattsperliter)
         {
-            double value = (double) decawattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.DecawattPerLiter);
+            return new PowerDensity(decawattsperliter, PowerDensityUnit.DecawattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicFoot(QuantityValue deciwattspercubicfoot)
+        public static PowerDensity FromDeciwattsPerCubicFoot(double deciwattspercubicfoot)
         {
-            double value = (double) deciwattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicFoot);
+            return new PowerDensity(deciwattspercubicfoot, PowerDensityUnit.DeciwattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicInch(QuantityValue deciwattspercubicinch)
+        public static PowerDensity FromDeciwattsPerCubicInch(double deciwattspercubicinch)
         {
-            double value = (double) deciwattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicInch);
+            return new PowerDensity(deciwattspercubicinch, PowerDensityUnit.DeciwattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicMeter(QuantityValue deciwattspercubicmeter)
+        public static PowerDensity FromDeciwattsPerCubicMeter(double deciwattspercubicmeter)
         {
-            double value = (double) deciwattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicMeter);
+            return new PowerDensity(deciwattspercubicmeter, PowerDensityUnit.DeciwattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerLiter(QuantityValue deciwattsperliter)
+        public static PowerDensity FromDeciwattsPerLiter(double deciwattsperliter)
         {
-            double value = (double) deciwattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.DeciwattPerLiter);
+            return new PowerDensity(deciwattsperliter, PowerDensityUnit.DeciwattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicFoot(QuantityValue gigawattspercubicfoot)
+        public static PowerDensity FromGigawattsPerCubicFoot(double gigawattspercubicfoot)
         {
-            double value = (double) gigawattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicFoot);
+            return new PowerDensity(gigawattspercubicfoot, PowerDensityUnit.GigawattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicInch(QuantityValue gigawattspercubicinch)
+        public static PowerDensity FromGigawattsPerCubicInch(double gigawattspercubicinch)
         {
-            double value = (double) gigawattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicInch);
+            return new PowerDensity(gigawattspercubicinch, PowerDensityUnit.GigawattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicMeter(QuantityValue gigawattspercubicmeter)
+        public static PowerDensity FromGigawattsPerCubicMeter(double gigawattspercubicmeter)
         {
-            double value = (double) gigawattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicMeter);
+            return new PowerDensity(gigawattspercubicmeter, PowerDensityUnit.GigawattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerLiter(QuantityValue gigawattsperliter)
+        public static PowerDensity FromGigawattsPerLiter(double gigawattsperliter)
         {
-            double value = (double) gigawattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.GigawattPerLiter);
+            return new PowerDensity(gigawattsperliter, PowerDensityUnit.GigawattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicFoot(QuantityValue kilowattspercubicfoot)
+        public static PowerDensity FromKilowattsPerCubicFoot(double kilowattspercubicfoot)
         {
-            double value = (double) kilowattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicFoot);
+            return new PowerDensity(kilowattspercubicfoot, PowerDensityUnit.KilowattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicInch(QuantityValue kilowattspercubicinch)
+        public static PowerDensity FromKilowattsPerCubicInch(double kilowattspercubicinch)
         {
-            double value = (double) kilowattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicInch);
+            return new PowerDensity(kilowattspercubicinch, PowerDensityUnit.KilowattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicMeter(QuantityValue kilowattspercubicmeter)
+        public static PowerDensity FromKilowattsPerCubicMeter(double kilowattspercubicmeter)
         {
-            double value = (double) kilowattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicMeter);
+            return new PowerDensity(kilowattspercubicmeter, PowerDensityUnit.KilowattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerLiter(QuantityValue kilowattsperliter)
+        public static PowerDensity FromKilowattsPerLiter(double kilowattsperliter)
         {
-            double value = (double) kilowattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.KilowattPerLiter);
+            return new PowerDensity(kilowattsperliter, PowerDensityUnit.KilowattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicFoot(QuantityValue megawattspercubicfoot)
+        public static PowerDensity FromMegawattsPerCubicFoot(double megawattspercubicfoot)
         {
-            double value = (double) megawattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicFoot);
+            return new PowerDensity(megawattspercubicfoot, PowerDensityUnit.MegawattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicInch(QuantityValue megawattspercubicinch)
+        public static PowerDensity FromMegawattsPerCubicInch(double megawattspercubicinch)
         {
-            double value = (double) megawattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicInch);
+            return new PowerDensity(megawattspercubicinch, PowerDensityUnit.MegawattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicMeter(QuantityValue megawattspercubicmeter)
+        public static PowerDensity FromMegawattsPerCubicMeter(double megawattspercubicmeter)
         {
-            double value = (double) megawattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicMeter);
+            return new PowerDensity(megawattspercubicmeter, PowerDensityUnit.MegawattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerLiter(QuantityValue megawattsperliter)
+        public static PowerDensity FromMegawattsPerLiter(double megawattsperliter)
         {
-            double value = (double) megawattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.MegawattPerLiter);
+            return new PowerDensity(megawattsperliter, PowerDensityUnit.MegawattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicFoot(QuantityValue microwattspercubicfoot)
+        public static PowerDensity FromMicrowattsPerCubicFoot(double microwattspercubicfoot)
         {
-            double value = (double) microwattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicFoot);
+            return new PowerDensity(microwattspercubicfoot, PowerDensityUnit.MicrowattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicInch(QuantityValue microwattspercubicinch)
+        public static PowerDensity FromMicrowattsPerCubicInch(double microwattspercubicinch)
         {
-            double value = (double) microwattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicInch);
+            return new PowerDensity(microwattspercubicinch, PowerDensityUnit.MicrowattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicMeter(QuantityValue microwattspercubicmeter)
+        public static PowerDensity FromMicrowattsPerCubicMeter(double microwattspercubicmeter)
         {
-            double value = (double) microwattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicMeter);
+            return new PowerDensity(microwattspercubicmeter, PowerDensityUnit.MicrowattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerLiter(QuantityValue microwattsperliter)
+        public static PowerDensity FromMicrowattsPerLiter(double microwattsperliter)
         {
-            double value = (double) microwattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.MicrowattPerLiter);
+            return new PowerDensity(microwattsperliter, PowerDensityUnit.MicrowattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicFoot(QuantityValue milliwattspercubicfoot)
+        public static PowerDensity FromMilliwattsPerCubicFoot(double milliwattspercubicfoot)
         {
-            double value = (double) milliwattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicFoot);
+            return new PowerDensity(milliwattspercubicfoot, PowerDensityUnit.MilliwattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicInch(QuantityValue milliwattspercubicinch)
+        public static PowerDensity FromMilliwattsPerCubicInch(double milliwattspercubicinch)
         {
-            double value = (double) milliwattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicInch);
+            return new PowerDensity(milliwattspercubicinch, PowerDensityUnit.MilliwattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicMeter(QuantityValue milliwattspercubicmeter)
+        public static PowerDensity FromMilliwattsPerCubicMeter(double milliwattspercubicmeter)
         {
-            double value = (double) milliwattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicMeter);
+            return new PowerDensity(milliwattspercubicmeter, PowerDensityUnit.MilliwattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerLiter(QuantityValue milliwattsperliter)
+        public static PowerDensity FromMilliwattsPerLiter(double milliwattsperliter)
         {
-            double value = (double) milliwattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.MilliwattPerLiter);
+            return new PowerDensity(milliwattsperliter, PowerDensityUnit.MilliwattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicFoot(QuantityValue nanowattspercubicfoot)
+        public static PowerDensity FromNanowattsPerCubicFoot(double nanowattspercubicfoot)
         {
-            double value = (double) nanowattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicFoot);
+            return new PowerDensity(nanowattspercubicfoot, PowerDensityUnit.NanowattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicInch(QuantityValue nanowattspercubicinch)
+        public static PowerDensity FromNanowattsPerCubicInch(double nanowattspercubicinch)
         {
-            double value = (double) nanowattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicInch);
+            return new PowerDensity(nanowattspercubicinch, PowerDensityUnit.NanowattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicMeter(QuantityValue nanowattspercubicmeter)
+        public static PowerDensity FromNanowattsPerCubicMeter(double nanowattspercubicmeter)
         {
-            double value = (double) nanowattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicMeter);
+            return new PowerDensity(nanowattspercubicmeter, PowerDensityUnit.NanowattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerLiter(QuantityValue nanowattsperliter)
+        public static PowerDensity FromNanowattsPerLiter(double nanowattsperliter)
         {
-            double value = (double) nanowattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.NanowattPerLiter);
+            return new PowerDensity(nanowattsperliter, PowerDensityUnit.NanowattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicFoot(QuantityValue picowattspercubicfoot)
+        public static PowerDensity FromPicowattsPerCubicFoot(double picowattspercubicfoot)
         {
-            double value = (double) picowattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicFoot);
+            return new PowerDensity(picowattspercubicfoot, PowerDensityUnit.PicowattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicInch(QuantityValue picowattspercubicinch)
+        public static PowerDensity FromPicowattsPerCubicInch(double picowattspercubicinch)
         {
-            double value = (double) picowattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicInch);
+            return new PowerDensity(picowattspercubicinch, PowerDensityUnit.PicowattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicMeter(QuantityValue picowattspercubicmeter)
+        public static PowerDensity FromPicowattsPerCubicMeter(double picowattspercubicmeter)
         {
-            double value = (double) picowattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicMeter);
+            return new PowerDensity(picowattspercubicmeter, PowerDensityUnit.PicowattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerLiter(QuantityValue picowattsperliter)
+        public static PowerDensity FromPicowattsPerLiter(double picowattsperliter)
         {
-            double value = (double) picowattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.PicowattPerLiter);
+            return new PowerDensity(picowattsperliter, PowerDensityUnit.PicowattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicFoot(QuantityValue terawattspercubicfoot)
+        public static PowerDensity FromTerawattsPerCubicFoot(double terawattspercubicfoot)
         {
-            double value = (double) terawattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicFoot);
+            return new PowerDensity(terawattspercubicfoot, PowerDensityUnit.TerawattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicInch(QuantityValue terawattspercubicinch)
+        public static PowerDensity FromTerawattsPerCubicInch(double terawattspercubicinch)
         {
-            double value = (double) terawattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicInch);
+            return new PowerDensity(terawattspercubicinch, PowerDensityUnit.TerawattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicMeter(QuantityValue terawattspercubicmeter)
+        public static PowerDensity FromTerawattsPerCubicMeter(double terawattspercubicmeter)
         {
-            double value = (double) terawattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicMeter);
+            return new PowerDensity(terawattspercubicmeter, PowerDensityUnit.TerawattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerLiter(QuantityValue terawattsperliter)
+        public static PowerDensity FromTerawattsPerLiter(double terawattsperliter)
         {
-            double value = (double) terawattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.TerawattPerLiter);
+            return new PowerDensity(terawattsperliter, PowerDensityUnit.TerawattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicFoot(QuantityValue wattspercubicfoot)
+        public static PowerDensity FromWattsPerCubicFoot(double wattspercubicfoot)
         {
-            double value = (double) wattspercubicfoot;
-            return new PowerDensity(value, PowerDensityUnit.WattPerCubicFoot);
+            return new PowerDensity(wattspercubicfoot, PowerDensityUnit.WattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicInch(QuantityValue wattspercubicinch)
+        public static PowerDensity FromWattsPerCubicInch(double wattspercubicinch)
         {
-            double value = (double) wattspercubicinch;
-            return new PowerDensity(value, PowerDensityUnit.WattPerCubicInch);
+            return new PowerDensity(wattspercubicinch, PowerDensityUnit.WattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicMeter(QuantityValue wattspercubicmeter)
+        public static PowerDensity FromWattsPerCubicMeter(double wattspercubicmeter)
         {
-            double value = (double) wattspercubicmeter;
-            return new PowerDensity(value, PowerDensityUnit.WattPerCubicMeter);
+            return new PowerDensity(wattspercubicmeter, PowerDensityUnit.WattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerLiter(QuantityValue wattsperliter)
+        public static PowerDensity FromWattsPerLiter(double wattsperliter)
         {
-            double value = (double) wattsperliter;
-            return new PowerDensity(value, PowerDensityUnit.WattPerLiter);
+            return new PowerDensity(wattsperliter, PowerDensityUnit.WattPerLiter);
         }
 
         /// <summary>
@@ -1007,9 +963,9 @@ public static PowerDensity FromWattsPerLiter(QuantityValue wattsperliter)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>PowerDensity unit value.</returns>
-        public static PowerDensity From(QuantityValue value, PowerDensityUnit fromUnit)
+        public static PowerDensity From(double value, PowerDensityUnit fromUnit)
         {
-            return new PowerDensity((double)value, fromUnit);
+            return new PowerDensity(value, fromUnit);
         }
 
         #endregion
@@ -1420,15 +1376,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is PowerDensityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerDensityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is PowerDensityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerDensityUnit)} is supported.", nameof(unit));
@@ -1629,18 +1576,6 @@ public PowerDensity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PowerDensityUnit> IQuantity<PowerDensityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not PowerDensityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerDensityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
index ea2ee3c7d6..32d914c432 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct PowerRatio :
-        IArithmeticQuantity<PowerRatio, PowerRatioUnit, double>,
+        IArithmeticQuantity<PowerRatio, PowerRatioUnit>,
         IComparable,
         IComparable<PowerRatio>,
         IConvertible,
@@ -148,7 +148,7 @@ public PowerRatio(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -229,20 +229,18 @@ public static string GetAbbreviation(PowerRatioUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="PowerRatio"/> from <see cref="PowerRatioUnit.DecibelMilliwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerRatio FromDecibelMilliwatts(QuantityValue decibelmilliwatts)
+        public static PowerRatio FromDecibelMilliwatts(double decibelmilliwatts)
         {
-            double value = (double) decibelmilliwatts;
-            return new PowerRatio(value, PowerRatioUnit.DecibelMilliwatt);
+            return new PowerRatio(decibelmilliwatts, PowerRatioUnit.DecibelMilliwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerRatio"/> from <see cref="PowerRatioUnit.DecibelWatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerRatio FromDecibelWatts(QuantityValue decibelwatts)
+        public static PowerRatio FromDecibelWatts(double decibelwatts)
         {
-            double value = (double) decibelwatts;
-            return new PowerRatio(value, PowerRatioUnit.DecibelWatt);
+            return new PowerRatio(decibelwatts, PowerRatioUnit.DecibelWatt);
         }
 
         /// <summary>
@@ -251,9 +249,9 @@ public static PowerRatio FromDecibelWatts(QuantityValue decibelwatts)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>PowerRatio unit value.</returns>
-        public static PowerRatio From(QuantityValue value, PowerRatioUnit fromUnit)
+        public static PowerRatio From(double value, PowerRatioUnit fromUnit)
         {
-            return new PowerRatio((double)value, fromUnit);
+            return new PowerRatio(value, fromUnit);
         }
 
         #endregion
@@ -437,14 +435,14 @@ public static bool TryParseUnit(string str, IFormatProvider? provider, out Power
         public static PowerRatio operator *(PowerRatio left, double right)
         {
             // Logarithmic multiplication = addition
-            return new PowerRatio(left.Value + (double)right, left.Unit);
+            return new PowerRatio(left.Value + right, left.Unit);
         }
 
         /// <summary>Get <see cref="PowerRatio"/> from logarithmic division of <see cref="PowerRatio"/> by value.</summary>
         public static PowerRatio operator /(PowerRatio left, double right)
         {
             // Logarithmic division = subtraction
-            return new PowerRatio(left.Value - (double)right, left.Unit);
+            return new PowerRatio(left.Value - right, left.Unit);
         }
 
         /// <summary>Get ratio value from logarithmic division of <see cref="PowerRatio"/> by <see cref="PowerRatio"/>.</summary>
@@ -672,15 +670,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is PowerRatioUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerRatioUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is PowerRatioUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerRatioUnit)} is supported.", nameof(unit));
@@ -797,18 +786,6 @@ public PowerRatio ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PowerRatioUnit> IQuantity<PowerRatioUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not PowerRatioUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PowerRatioUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
index 38e86ad76c..a0c06f2a49 100644
--- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Pressure :
-        IArithmeticQuantity<Pressure, PressureUnit, double>,
+        IArithmeticQuantity<Pressure, PressureUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<Pressure, Area, Force>,
         IDivisionOperators<Pressure, ReciprocalArea, Force>,
@@ -207,7 +207,7 @@ public Pressure(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -617,490 +617,441 @@ public static string GetAbbreviation(PressureUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Atmosphere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromAtmospheres(QuantityValue atmospheres)
+        public static Pressure FromAtmospheres(double atmospheres)
         {
-            double value = (double) atmospheres;
-            return new Pressure(value, PressureUnit.Atmosphere);
+            return new Pressure(atmospheres, PressureUnit.Atmosphere);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Bar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromBars(QuantityValue bars)
+        public static Pressure FromBars(double bars)
         {
-            double value = (double) bars;
-            return new Pressure(value, PressureUnit.Bar);
+            return new Pressure(bars, PressureUnit.Bar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Centibar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromCentibars(QuantityValue centibars)
+        public static Pressure FromCentibars(double centibars)
         {
-            double value = (double) centibars;
-            return new Pressure(value, PressureUnit.Centibar);
+            return new Pressure(centibars, PressureUnit.Centibar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.CentimeterOfWaterColumn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromCentimetersOfWaterColumn(QuantityValue centimetersofwatercolumn)
+        public static Pressure FromCentimetersOfWaterColumn(double centimetersofwatercolumn)
         {
-            double value = (double) centimetersofwatercolumn;
-            return new Pressure(value, PressureUnit.CentimeterOfWaterColumn);
+            return new Pressure(centimetersofwatercolumn, PressureUnit.CentimeterOfWaterColumn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Decapascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDecapascals(QuantityValue decapascals)
+        public static Pressure FromDecapascals(double decapascals)
         {
-            double value = (double) decapascals;
-            return new Pressure(value, PressureUnit.Decapascal);
+            return new Pressure(decapascals, PressureUnit.Decapascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Decibar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDecibars(QuantityValue decibars)
+        public static Pressure FromDecibars(double decibars)
         {
-            double value = (double) decibars;
-            return new Pressure(value, PressureUnit.Decibar);
+            return new Pressure(decibars, PressureUnit.Decibar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.DynePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDynesPerSquareCentimeter(QuantityValue dynespersquarecentimeter)
+        public static Pressure FromDynesPerSquareCentimeter(double dynespersquarecentimeter)
         {
-            double value = (double) dynespersquarecentimeter;
-            return new Pressure(value, PressureUnit.DynePerSquareCentimeter);
+            return new Pressure(dynespersquarecentimeter, PressureUnit.DynePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.FootOfElevation"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromFeetOfElevation(QuantityValue feetofelevation)
+        public static Pressure FromFeetOfElevation(double feetofelevation)
         {
-            double value = (double) feetofelevation;
-            return new Pressure(value, PressureUnit.FootOfElevation);
+            return new Pressure(feetofelevation, PressureUnit.FootOfElevation);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.FootOfHead"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromFeetOfHead(QuantityValue feetofhead)
+        public static Pressure FromFeetOfHead(double feetofhead)
         {
-            double value = (double) feetofhead;
-            return new Pressure(value, PressureUnit.FootOfHead);
+            return new Pressure(feetofhead, PressureUnit.FootOfHead);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Gigapascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromGigapascals(QuantityValue gigapascals)
+        public static Pressure FromGigapascals(double gigapascals)
         {
-            double value = (double) gigapascals;
-            return new Pressure(value, PressureUnit.Gigapascal);
+            return new Pressure(gigapascals, PressureUnit.Gigapascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Hectopascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromHectopascals(QuantityValue hectopascals)
+        public static Pressure FromHectopascals(double hectopascals)
         {
-            double value = (double) hectopascals;
-            return new Pressure(value, PressureUnit.Hectopascal);
+            return new Pressure(hectopascals, PressureUnit.Hectopascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.InchOfMercury"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromInchesOfMercury(QuantityValue inchesofmercury)
+        public static Pressure FromInchesOfMercury(double inchesofmercury)
         {
-            double value = (double) inchesofmercury;
-            return new Pressure(value, PressureUnit.InchOfMercury);
+            return new Pressure(inchesofmercury, PressureUnit.InchOfMercury);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.InchOfWaterColumn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromInchesOfWaterColumn(QuantityValue inchesofwatercolumn)
+        public static Pressure FromInchesOfWaterColumn(double inchesofwatercolumn)
         {
-            double value = (double) inchesofwatercolumn;
-            return new Pressure(value, PressureUnit.InchOfWaterColumn);
+            return new Pressure(inchesofwatercolumn, PressureUnit.InchOfWaterColumn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Kilobar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilobars(QuantityValue kilobars)
+        public static Pressure FromKilobars(double kilobars)
         {
-            double value = (double) kilobars;
-            return new Pressure(value, PressureUnit.Kilobar);
+            return new Pressure(kilobars, PressureUnit.Kilobar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareCentimeter(QuantityValue kilogramsforcepersquarecentimeter)
+        public static Pressure FromKilogramsForcePerSquareCentimeter(double kilogramsforcepersquarecentimeter)
         {
-            double value = (double) kilogramsforcepersquarecentimeter;
-            return new Pressure(value, PressureUnit.KilogramForcePerSquareCentimeter);
+            return new Pressure(kilogramsforcepersquarecentimeter, PressureUnit.KilogramForcePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareMeter(QuantityValue kilogramsforcepersquaremeter)
+        public static Pressure FromKilogramsForcePerSquareMeter(double kilogramsforcepersquaremeter)
         {
-            double value = (double) kilogramsforcepersquaremeter;
-            return new Pressure(value, PressureUnit.KilogramForcePerSquareMeter);
+            return new Pressure(kilogramsforcepersquaremeter, PressureUnit.KilogramForcePerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareMillimeter(QuantityValue kilogramsforcepersquaremillimeter)
+        public static Pressure FromKilogramsForcePerSquareMillimeter(double kilogramsforcepersquaremillimeter)
         {
-            double value = (double) kilogramsforcepersquaremillimeter;
-            return new Pressure(value, PressureUnit.KilogramForcePerSquareMillimeter);
+            return new Pressure(kilogramsforcepersquaremillimeter, PressureUnit.KilogramForcePerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareCentimeter(QuantityValue kilonewtonspersquarecentimeter)
+        public static Pressure FromKilonewtonsPerSquareCentimeter(double kilonewtonspersquarecentimeter)
         {
-            double value = (double) kilonewtonspersquarecentimeter;
-            return new Pressure(value, PressureUnit.KilonewtonPerSquareCentimeter);
+            return new Pressure(kilonewtonspersquarecentimeter, PressureUnit.KilonewtonPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareMeter(QuantityValue kilonewtonspersquaremeter)
+        public static Pressure FromKilonewtonsPerSquareMeter(double kilonewtonspersquaremeter)
         {
-            double value = (double) kilonewtonspersquaremeter;
-            return new Pressure(value, PressureUnit.KilonewtonPerSquareMeter);
+            return new Pressure(kilonewtonspersquaremeter, PressureUnit.KilonewtonPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareMillimeter(QuantityValue kilonewtonspersquaremillimeter)
+        public static Pressure FromKilonewtonsPerSquareMillimeter(double kilonewtonspersquaremillimeter)
         {
-            double value = (double) kilonewtonspersquaremillimeter;
-            return new Pressure(value, PressureUnit.KilonewtonPerSquareMillimeter);
+            return new Pressure(kilonewtonspersquaremillimeter, PressureUnit.KilonewtonPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Kilopascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopascals(QuantityValue kilopascals)
+        public static Pressure FromKilopascals(double kilopascals)
         {
-            double value = (double) kilopascals;
-            return new Pressure(value, PressureUnit.Kilopascal);
+            return new Pressure(kilopascals, PressureUnit.Kilopascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopoundsForcePerSquareFoot(QuantityValue kilopoundsforcepersquarefoot)
+        public static Pressure FromKilopoundsForcePerSquareFoot(double kilopoundsforcepersquarefoot)
         {
-            double value = (double) kilopoundsforcepersquarefoot;
-            return new Pressure(value, PressureUnit.KilopoundForcePerSquareFoot);
+            return new Pressure(kilopoundsforcepersquarefoot, PressureUnit.KilopoundForcePerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopoundsForcePerSquareInch(QuantityValue kilopoundsforcepersquareinch)
+        public static Pressure FromKilopoundsForcePerSquareInch(double kilopoundsforcepersquareinch)
         {
-            double value = (double) kilopoundsforcepersquareinch;
-            return new Pressure(value, PressureUnit.KilopoundForcePerSquareInch);
+            return new Pressure(kilopoundsforcepersquareinch, PressureUnit.KilopoundForcePerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareMil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopoundsForcePerSquareMil(QuantityValue kilopoundsforcepersquaremil)
+        public static Pressure FromKilopoundsForcePerSquareMil(double kilopoundsforcepersquaremil)
         {
-            double value = (double) kilopoundsforcepersquaremil;
-            return new Pressure(value, PressureUnit.KilopoundForcePerSquareMil);
+            return new Pressure(kilopoundsforcepersquaremil, PressureUnit.KilopoundForcePerSquareMil);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Megabar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMegabars(QuantityValue megabars)
+        public static Pressure FromMegabars(double megabars)
         {
-            double value = (double) megabars;
-            return new Pressure(value, PressureUnit.Megabar);
+            return new Pressure(megabars, PressureUnit.Megabar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeganewtonPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMeganewtonsPerSquareMeter(QuantityValue meganewtonspersquaremeter)
+        public static Pressure FromMeganewtonsPerSquareMeter(double meganewtonspersquaremeter)
         {
-            double value = (double) meganewtonspersquaremeter;
-            return new Pressure(value, PressureUnit.MeganewtonPerSquareMeter);
+            return new Pressure(meganewtonspersquaremeter, PressureUnit.MeganewtonPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Megapascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMegapascals(QuantityValue megapascals)
+        public static Pressure FromMegapascals(double megapascals)
         {
-            double value = (double) megapascals;
-            return new Pressure(value, PressureUnit.Megapascal);
+            return new Pressure(megapascals, PressureUnit.Megapascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfElevation"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMetersOfElevation(QuantityValue metersofelevation)
+        public static Pressure FromMetersOfElevation(double metersofelevation)
         {
-            double value = (double) metersofelevation;
-            return new Pressure(value, PressureUnit.MeterOfElevation);
+            return new Pressure(metersofelevation, PressureUnit.MeterOfElevation);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfHead"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMetersOfHead(QuantityValue metersofhead)
+        public static Pressure FromMetersOfHead(double metersofhead)
         {
-            double value = (double) metersofhead;
-            return new Pressure(value, PressureUnit.MeterOfHead);
+            return new Pressure(metersofhead, PressureUnit.MeterOfHead);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfWaterColumn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMetersOfWaterColumn(QuantityValue metersofwatercolumn)
+        public static Pressure FromMetersOfWaterColumn(double metersofwatercolumn)
         {
-            double value = (double) metersofwatercolumn;
-            return new Pressure(value, PressureUnit.MeterOfWaterColumn);
+            return new Pressure(metersofwatercolumn, PressureUnit.MeterOfWaterColumn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Microbar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMicrobars(QuantityValue microbars)
+        public static Pressure FromMicrobars(double microbars)
         {
-            double value = (double) microbars;
-            return new Pressure(value, PressureUnit.Microbar);
+            return new Pressure(microbars, PressureUnit.Microbar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Micropascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMicropascals(QuantityValue micropascals)
+        public static Pressure FromMicropascals(double micropascals)
         {
-            double value = (double) micropascals;
-            return new Pressure(value, PressureUnit.Micropascal);
+            return new Pressure(micropascals, PressureUnit.Micropascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millibar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillibars(QuantityValue millibars)
+        public static Pressure FromMillibars(double millibars)
         {
-            double value = (double) millibars;
-            return new Pressure(value, PressureUnit.Millibar);
+            return new Pressure(millibars, PressureUnit.Millibar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MillimeterOfMercury"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillimetersOfMercury(QuantityValue millimetersofmercury)
+        public static Pressure FromMillimetersOfMercury(double millimetersofmercury)
         {
-            double value = (double) millimetersofmercury;
-            return new Pressure(value, PressureUnit.MillimeterOfMercury);
+            return new Pressure(millimetersofmercury, PressureUnit.MillimeterOfMercury);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MillimeterOfWaterColumn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillimetersOfWaterColumn(QuantityValue millimetersofwatercolumn)
+        public static Pressure FromMillimetersOfWaterColumn(double millimetersofwatercolumn)
         {
-            double value = (double) millimetersofwatercolumn;
-            return new Pressure(value, PressureUnit.MillimeterOfWaterColumn);
+            return new Pressure(millimetersofwatercolumn, PressureUnit.MillimeterOfWaterColumn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millipascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillipascals(QuantityValue millipascals)
+        public static Pressure FromMillipascals(double millipascals)
         {
-            double value = (double) millipascals;
-            return new Pressure(value, PressureUnit.Millipascal);
+            return new Pressure(millipascals, PressureUnit.Millipascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareCentimeter(QuantityValue newtonspersquarecentimeter)
+        public static Pressure FromNewtonsPerSquareCentimeter(double newtonspersquarecentimeter)
         {
-            double value = (double) newtonspersquarecentimeter;
-            return new Pressure(value, PressureUnit.NewtonPerSquareCentimeter);
+            return new Pressure(newtonspersquarecentimeter, PressureUnit.NewtonPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareMeter(QuantityValue newtonspersquaremeter)
+        public static Pressure FromNewtonsPerSquareMeter(double newtonspersquaremeter)
         {
-            double value = (double) newtonspersquaremeter;
-            return new Pressure(value, PressureUnit.NewtonPerSquareMeter);
+            return new Pressure(newtonspersquaremeter, PressureUnit.NewtonPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareMillimeter(QuantityValue newtonspersquaremillimeter)
+        public static Pressure FromNewtonsPerSquareMillimeter(double newtonspersquaremillimeter)
         {
-            double value = (double) newtonspersquaremillimeter;
-            return new Pressure(value, PressureUnit.NewtonPerSquareMillimeter);
+            return new Pressure(newtonspersquaremillimeter, PressureUnit.NewtonPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Pascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPascals(QuantityValue pascals)
+        public static Pressure FromPascals(double pascals)
         {
-            double value = (double) pascals;
-            return new Pressure(value, PressureUnit.Pascal);
+            return new Pressure(pascals, PressureUnit.Pascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsForcePerSquareFoot(QuantityValue poundsforcepersquarefoot)
+        public static Pressure FromPoundsForcePerSquareFoot(double poundsforcepersquarefoot)
         {
-            double value = (double) poundsforcepersquarefoot;
-            return new Pressure(value, PressureUnit.PoundForcePerSquareFoot);
+            return new Pressure(poundsforcepersquarefoot, PressureUnit.PoundForcePerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsForcePerSquareInch(QuantityValue poundsforcepersquareinch)
+        public static Pressure FromPoundsForcePerSquareInch(double poundsforcepersquareinch)
         {
-            double value = (double) poundsforcepersquareinch;
-            return new Pressure(value, PressureUnit.PoundForcePerSquareInch);
+            return new Pressure(poundsforcepersquareinch, PressureUnit.PoundForcePerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareMil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsForcePerSquareMil(QuantityValue poundsforcepersquaremil)
+        public static Pressure FromPoundsForcePerSquareMil(double poundsforcepersquaremil)
         {
-            double value = (double) poundsforcepersquaremil;
-            return new Pressure(value, PressureUnit.PoundForcePerSquareMil);
+            return new Pressure(poundsforcepersquaremil, PressureUnit.PoundForcePerSquareMil);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundPerInchSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsPerInchSecondSquared(QuantityValue poundsperinchsecondsquared)
+        public static Pressure FromPoundsPerInchSecondSquared(double poundsperinchsecondsquared)
         {
-            double value = (double) poundsperinchsecondsquared;
-            return new Pressure(value, PressureUnit.PoundPerInchSecondSquared);
+            return new Pressure(poundsperinchsecondsquared, PressureUnit.PoundPerInchSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TechnicalAtmosphere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTechnicalAtmospheres(QuantityValue technicalatmospheres)
+        public static Pressure FromTechnicalAtmospheres(double technicalatmospheres)
         {
-            double value = (double) technicalatmospheres;
-            return new Pressure(value, PressureUnit.TechnicalAtmosphere);
+            return new Pressure(technicalatmospheres, PressureUnit.TechnicalAtmosphere);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareCentimeter(QuantityValue tonnesforcepersquarecentimeter)
+        public static Pressure FromTonnesForcePerSquareCentimeter(double tonnesforcepersquarecentimeter)
         {
-            double value = (double) tonnesforcepersquarecentimeter;
-            return new Pressure(value, PressureUnit.TonneForcePerSquareCentimeter);
+            return new Pressure(tonnesforcepersquarecentimeter, PressureUnit.TonneForcePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareMeter(QuantityValue tonnesforcepersquaremeter)
+        public static Pressure FromTonnesForcePerSquareMeter(double tonnesforcepersquaremeter)
         {
-            double value = (double) tonnesforcepersquaremeter;
-            return new Pressure(value, PressureUnit.TonneForcePerSquareMeter);
+            return new Pressure(tonnesforcepersquaremeter, PressureUnit.TonneForcePerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareMillimeter(QuantityValue tonnesforcepersquaremillimeter)
+        public static Pressure FromTonnesForcePerSquareMillimeter(double tonnesforcepersquaremillimeter)
         {
-            double value = (double) tonnesforcepersquaremillimeter;
-            return new Pressure(value, PressureUnit.TonneForcePerSquareMillimeter);
+            return new Pressure(tonnesforcepersquaremillimeter, PressureUnit.TonneForcePerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Torr"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTorrs(QuantityValue torrs)
+        public static Pressure FromTorrs(double torrs)
         {
-            double value = (double) torrs;
-            return new Pressure(value, PressureUnit.Torr);
+            return new Pressure(torrs, PressureUnit.Torr);
         }
 
         /// <summary>
@@ -1109,9 +1060,9 @@ public static Pressure FromTorrs(QuantityValue torrs)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Pressure unit value.</returns>
-        public static Pressure From(QuantityValue value, PressureUnit fromUnit)
+        public static Pressure From(double value, PressureUnit fromUnit)
         {
-            return new Pressure((double)value, fromUnit);
+            return new Pressure(value, fromUnit);
         }
 
         #endregion
@@ -1568,15 +1519,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is PressureUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is PressureUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureUnit)} is supported.", nameof(unit));
@@ -1787,18 +1729,6 @@ public Pressure ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PressureUnit> IQuantity<PressureUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not PressureUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
index 4a857e3e2a..e7db9ac5b0 100644
--- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct PressureChangeRate :
-        IArithmeticQuantity<PressureChangeRate, PressureChangeRateUnit, double>,
+        IArithmeticQuantity<PressureChangeRate, PressureChangeRateUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<PressureChangeRate, Duration, Pressure>,
         IMultiplyOperators<PressureChangeRate, TimeSpan, Pressure>,
@@ -171,7 +171,7 @@ public PressureChangeRate(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -364,180 +364,162 @@ public static string GetAbbreviation(PressureChangeRateUnit unit, IFormatProvide
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.AtmospherePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromAtmospheresPerSecond(QuantityValue atmospherespersecond)
+        public static PressureChangeRate FromAtmospheresPerSecond(double atmospherespersecond)
         {
-            double value = (double) atmospherespersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond);
+            return new PressureChangeRate(atmospherespersecond, PressureChangeRateUnit.AtmospherePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.BarPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromBarsPerMinute(QuantityValue barsperminute)
+        public static PressureChangeRate FromBarsPerMinute(double barsperminute)
         {
-            double value = (double) barsperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.BarPerMinute);
+            return new PressureChangeRate(barsperminute, PressureChangeRateUnit.BarPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.BarPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromBarsPerSecond(QuantityValue barspersecond)
+        public static PressureChangeRate FromBarsPerSecond(double barspersecond)
         {
-            double value = (double) barspersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.BarPerSecond);
+            return new PressureChangeRate(barspersecond, PressureChangeRateUnit.BarPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopascalPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopascalsPerMinute(QuantityValue kilopascalsperminute)
+        public static PressureChangeRate FromKilopascalsPerMinute(double kilopascalsperminute)
         {
-            double value = (double) kilopascalsperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerMinute);
+            return new PressureChangeRate(kilopascalsperminute, PressureChangeRateUnit.KilopascalPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopascalPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopascalsPerSecond(QuantityValue kilopascalspersecond)
+        public static PressureChangeRate FromKilopascalsPerSecond(double kilopascalspersecond)
         {
-            double value = (double) kilopascalspersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond);
+            return new PressureChangeRate(kilopascalspersecond, PressureChangeRateUnit.KilopascalPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(QuantityValue kilopoundsforcepersquareinchperminute)
+        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(double kilopoundsforcepersquareinchperminute)
         {
-            double value = (double) kilopoundsforcepersquareinchperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
+            return new PressureChangeRate(kilopoundsforcepersquareinchperminute, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(QuantityValue kilopoundsforcepersquareinchpersecond)
+        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(double kilopoundsforcepersquareinchpersecond)
         {
-            double value = (double) kilopoundsforcepersquareinchpersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
+            return new PressureChangeRate(kilopoundsforcepersquareinchpersecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapascalPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapascalsPerMinute(QuantityValue megapascalsperminute)
+        public static PressureChangeRate FromMegapascalsPerMinute(double megapascalsperminute)
         {
-            double value = (double) megapascalsperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerMinute);
+            return new PressureChangeRate(megapascalsperminute, PressureChangeRateUnit.MegapascalPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapascalPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapascalsPerSecond(QuantityValue megapascalspersecond)
+        public static PressureChangeRate FromMegapascalsPerSecond(double megapascalspersecond)
         {
-            double value = (double) megapascalspersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond);
+            return new PressureChangeRate(megapascalspersecond, PressureChangeRateUnit.MegapascalPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(QuantityValue megapoundsforcepersquareinchperminute)
+        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(double megapoundsforcepersquareinchperminute)
         {
-            double value = (double) megapoundsforcepersquareinchperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
+            return new PressureChangeRate(megapoundsforcepersquareinchperminute, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(QuantityValue megapoundsforcepersquareinchpersecond)
+        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(double megapoundsforcepersquareinchpersecond)
         {
-            double value = (double) megapoundsforcepersquareinchpersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
+            return new PressureChangeRate(megapoundsforcepersquareinchpersecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillibarPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMillibarsPerMinute(QuantityValue millibarsperminute)
+        public static PressureChangeRate FromMillibarsPerMinute(double millibarsperminute)
         {
-            double value = (double) millibarsperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MillibarPerMinute);
+            return new PressureChangeRate(millibarsperminute, PressureChangeRateUnit.MillibarPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillibarPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMillibarsPerSecond(QuantityValue millibarspersecond)
+        public static PressureChangeRate FromMillibarsPerSecond(double millibarspersecond)
         {
-            double value = (double) millibarspersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MillibarPerSecond);
+            return new PressureChangeRate(millibarspersecond, PressureChangeRateUnit.MillibarPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillimeterOfMercuryPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMillimetersOfMercuryPerSecond(QuantityValue millimetersofmercurypersecond)
+        public static PressureChangeRate FromMillimetersOfMercuryPerSecond(double millimetersofmercurypersecond)
         {
-            double value = (double) millimetersofmercurypersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
+            return new PressureChangeRate(millimetersofmercurypersecond, PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PascalPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPascalsPerMinute(QuantityValue pascalsperminute)
+        public static PressureChangeRate FromPascalsPerMinute(double pascalsperminute)
         {
-            double value = (double) pascalsperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerMinute);
+            return new PressureChangeRate(pascalsperminute, PressureChangeRateUnit.PascalPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PascalPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPascalsPerSecond(QuantityValue pascalspersecond)
+        public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond)
         {
-            double value = (double) pascalspersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond);
+            return new PressureChangeRate(pascalspersecond, PressureChangeRateUnit.PascalPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(QuantityValue poundsforcepersquareinchperminute)
+        public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double poundsforcepersquareinchperminute)
         {
-            double value = (double) poundsforcepersquareinchperminute;
-            return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
+            return new PressureChangeRate(poundsforcepersquareinchperminute, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(QuantityValue poundsforcepersquareinchpersecond)
+        public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double poundsforcepersquareinchpersecond)
         {
-            double value = (double) poundsforcepersquareinchpersecond;
-            return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
+            return new PressureChangeRate(poundsforcepersquareinchpersecond, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
         }
 
         /// <summary>
@@ -546,9 +528,9 @@ public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(QuantityV
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>PressureChangeRate unit value.</returns>
-        public static PressureChangeRate From(QuantityValue value, PressureChangeRateUnit fromUnit)
+        public static PressureChangeRate From(double value, PressureChangeRateUnit fromUnit)
         {
-            return new PressureChangeRate((double)value, fromUnit);
+            return new PressureChangeRate(value, fromUnit);
         }
 
         #endregion
@@ -981,15 +963,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is PressureChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureChangeRateUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is PressureChangeRateUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureChangeRateUnit)} is supported.", nameof(unit));
@@ -1138,18 +1111,6 @@ public PressureChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<PressureChangeRateUnit> IQuantity<PressureChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not PressureChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(PressureChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs b/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
index f7214c4925..f611c99e5e 100644
--- a/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct RadiationExposure :
-        IArithmeticQuantity<RadiationExposure, RadiationExposureUnit, double>,
+        IArithmeticQuantity<RadiationExposure, RadiationExposureUnit>,
         IComparable,
         IComparable<RadiationExposure>,
         IConvertible,
@@ -154,7 +154,7 @@ public RadiationExposure(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -277,80 +277,72 @@ public static string GetAbbreviation(RadiationExposureUnit unit, IFormatProvider
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.CoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromCoulombsPerKilogram(QuantityValue coulombsperkilogram)
+        public static RadiationExposure FromCoulombsPerKilogram(double coulombsperkilogram)
         {
-            double value = (double) coulombsperkilogram;
-            return new RadiationExposure(value, RadiationExposureUnit.CoulombPerKilogram);
+            return new RadiationExposure(coulombsperkilogram, RadiationExposureUnit.CoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.MicrocoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromMicrocoulombsPerKilogram(QuantityValue microcoulombsperkilogram)
+        public static RadiationExposure FromMicrocoulombsPerKilogram(double microcoulombsperkilogram)
         {
-            double value = (double) microcoulombsperkilogram;
-            return new RadiationExposure(value, RadiationExposureUnit.MicrocoulombPerKilogram);
+            return new RadiationExposure(microcoulombsperkilogram, RadiationExposureUnit.MicrocoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Microroentgen"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromMicroroentgens(QuantityValue microroentgens)
+        public static RadiationExposure FromMicroroentgens(double microroentgens)
         {
-            double value = (double) microroentgens;
-            return new RadiationExposure(value, RadiationExposureUnit.Microroentgen);
+            return new RadiationExposure(microroentgens, RadiationExposureUnit.Microroentgen);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.MillicoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromMillicoulombsPerKilogram(QuantityValue millicoulombsperkilogram)
+        public static RadiationExposure FromMillicoulombsPerKilogram(double millicoulombsperkilogram)
         {
-            double value = (double) millicoulombsperkilogram;
-            return new RadiationExposure(value, RadiationExposureUnit.MillicoulombPerKilogram);
+            return new RadiationExposure(millicoulombsperkilogram, RadiationExposureUnit.MillicoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Milliroentgen"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromMilliroentgens(QuantityValue milliroentgens)
+        public static RadiationExposure FromMilliroentgens(double milliroentgens)
         {
-            double value = (double) milliroentgens;
-            return new RadiationExposure(value, RadiationExposureUnit.Milliroentgen);
+            return new RadiationExposure(milliroentgens, RadiationExposureUnit.Milliroentgen);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.NanocoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromNanocoulombsPerKilogram(QuantityValue nanocoulombsperkilogram)
+        public static RadiationExposure FromNanocoulombsPerKilogram(double nanocoulombsperkilogram)
         {
-            double value = (double) nanocoulombsperkilogram;
-            return new RadiationExposure(value, RadiationExposureUnit.NanocoulombPerKilogram);
+            return new RadiationExposure(nanocoulombsperkilogram, RadiationExposureUnit.NanocoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.PicocoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromPicocoulombsPerKilogram(QuantityValue picocoulombsperkilogram)
+        public static RadiationExposure FromPicocoulombsPerKilogram(double picocoulombsperkilogram)
         {
-            double value = (double) picocoulombsperkilogram;
-            return new RadiationExposure(value, RadiationExposureUnit.PicocoulombPerKilogram);
+            return new RadiationExposure(picocoulombsperkilogram, RadiationExposureUnit.PicocoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Roentgen"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromRoentgens(QuantityValue roentgens)
+        public static RadiationExposure FromRoentgens(double roentgens)
         {
-            double value = (double) roentgens;
-            return new RadiationExposure(value, RadiationExposureUnit.Roentgen);
+            return new RadiationExposure(roentgens, RadiationExposureUnit.Roentgen);
         }
 
         /// <summary>
@@ -359,9 +351,9 @@ public static RadiationExposure FromRoentgens(QuantityValue roentgens)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RadiationExposure unit value.</returns>
-        public static RadiationExposure From(QuantityValue value, RadiationExposureUnit fromUnit)
+        public static RadiationExposure From(double value, RadiationExposureUnit fromUnit)
         {
-            return new RadiationExposure((double)value, fromUnit);
+            return new RadiationExposure(value, fromUnit);
         }
 
         #endregion
@@ -772,15 +764,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RadiationExposureUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationExposureUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RadiationExposureUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationExposureUnit)} is supported.", nameof(unit));
@@ -909,18 +892,6 @@ public RadiationExposure ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RadiationExposureUnit> IQuantity<RadiationExposureUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RadiationExposureUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadiationExposureUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
index 215280f504..d44b97dd77 100644
--- a/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Radioactivity :
-        IArithmeticQuantity<Radioactivity, RadioactivityUnit, double>,
+        IArithmeticQuantity<Radioactivity, RadioactivityUnit>,
         IComparable,
         IComparable<Radioactivity>,
         IConvertible,
@@ -175,7 +175,7 @@ public Radioactivity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -445,290 +445,261 @@ public static string GetAbbreviation(RadioactivityUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Becquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromBecquerels(QuantityValue becquerels)
+        public static Radioactivity FromBecquerels(double becquerels)
         {
-            double value = (double) becquerels;
-            return new Radioactivity(value, RadioactivityUnit.Becquerel);
+            return new Radioactivity(becquerels, RadioactivityUnit.Becquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Curie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromCuries(QuantityValue curies)
+        public static Radioactivity FromCuries(double curies)
         {
-            double value = (double) curies;
-            return new Radioactivity(value, RadioactivityUnit.Curie);
+            return new Radioactivity(curies, RadioactivityUnit.Curie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Exabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromExabecquerels(QuantityValue exabecquerels)
+        public static Radioactivity FromExabecquerels(double exabecquerels)
         {
-            double value = (double) exabecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Exabecquerel);
+            return new Radioactivity(exabecquerels, RadioactivityUnit.Exabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromGigabecquerels(QuantityValue gigabecquerels)
+        public static Radioactivity FromGigabecquerels(double gigabecquerels)
         {
-            double value = (double) gigabecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Gigabecquerel);
+            return new Radioactivity(gigabecquerels, RadioactivityUnit.Gigabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigacurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromGigacuries(QuantityValue gigacuries)
+        public static Radioactivity FromGigacuries(double gigacuries)
         {
-            double value = (double) gigacuries;
-            return new Radioactivity(value, RadioactivityUnit.Gigacurie);
+            return new Radioactivity(gigacuries, RadioactivityUnit.Gigacurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigarutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromGigarutherfords(QuantityValue gigarutherfords)
+        public static Radioactivity FromGigarutherfords(double gigarutherfords)
         {
-            double value = (double) gigarutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Gigarutherford);
+            return new Radioactivity(gigarutherfords, RadioactivityUnit.Gigarutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilobecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromKilobecquerels(QuantityValue kilobecquerels)
+        public static Radioactivity FromKilobecquerels(double kilobecquerels)
         {
-            double value = (double) kilobecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Kilobecquerel);
+            return new Radioactivity(kilobecquerels, RadioactivityUnit.Kilobecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilocurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromKilocuries(QuantityValue kilocuries)
+        public static Radioactivity FromKilocuries(double kilocuries)
         {
-            double value = (double) kilocuries;
-            return new Radioactivity(value, RadioactivityUnit.Kilocurie);
+            return new Radioactivity(kilocuries, RadioactivityUnit.Kilocurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilorutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromKilorutherfords(QuantityValue kilorutherfords)
+        public static Radioactivity FromKilorutherfords(double kilorutherfords)
         {
-            double value = (double) kilorutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Kilorutherford);
+            return new Radioactivity(kilorutherfords, RadioactivityUnit.Kilorutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMegabecquerels(QuantityValue megabecquerels)
+        public static Radioactivity FromMegabecquerels(double megabecquerels)
         {
-            double value = (double) megabecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Megabecquerel);
+            return new Radioactivity(megabecquerels, RadioactivityUnit.Megabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megacurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMegacuries(QuantityValue megacuries)
+        public static Radioactivity FromMegacuries(double megacuries)
         {
-            double value = (double) megacuries;
-            return new Radioactivity(value, RadioactivityUnit.Megacurie);
+            return new Radioactivity(megacuries, RadioactivityUnit.Megacurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megarutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMegarutherfords(QuantityValue megarutherfords)
+        public static Radioactivity FromMegarutherfords(double megarutherfords)
         {
-            double value = (double) megarutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Megarutherford);
+            return new Radioactivity(megarutherfords, RadioactivityUnit.Megarutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microbecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMicrobecquerels(QuantityValue microbecquerels)
+        public static Radioactivity FromMicrobecquerels(double microbecquerels)
         {
-            double value = (double) microbecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Microbecquerel);
+            return new Radioactivity(microbecquerels, RadioactivityUnit.Microbecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microcurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMicrocuries(QuantityValue microcuries)
+        public static Radioactivity FromMicrocuries(double microcuries)
         {
-            double value = (double) microcuries;
-            return new Radioactivity(value, RadioactivityUnit.Microcurie);
+            return new Radioactivity(microcuries, RadioactivityUnit.Microcurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microrutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMicrorutherfords(QuantityValue microrutherfords)
+        public static Radioactivity FromMicrorutherfords(double microrutherfords)
         {
-            double value = (double) microrutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Microrutherford);
+            return new Radioactivity(microrutherfords, RadioactivityUnit.Microrutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millibecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMillibecquerels(QuantityValue millibecquerels)
+        public static Radioactivity FromMillibecquerels(double millibecquerels)
         {
-            double value = (double) millibecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Millibecquerel);
+            return new Radioactivity(millibecquerels, RadioactivityUnit.Millibecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millicurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMillicuries(QuantityValue millicuries)
+        public static Radioactivity FromMillicuries(double millicuries)
         {
-            double value = (double) millicuries;
-            return new Radioactivity(value, RadioactivityUnit.Millicurie);
+            return new Radioactivity(millicuries, RadioactivityUnit.Millicurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millirutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMillirutherfords(QuantityValue millirutherfords)
+        public static Radioactivity FromMillirutherfords(double millirutherfords)
         {
-            double value = (double) millirutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Millirutherford);
+            return new Radioactivity(millirutherfords, RadioactivityUnit.Millirutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanobecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromNanobecquerels(QuantityValue nanobecquerels)
+        public static Radioactivity FromNanobecquerels(double nanobecquerels)
         {
-            double value = (double) nanobecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Nanobecquerel);
+            return new Radioactivity(nanobecquerels, RadioactivityUnit.Nanobecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanocurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromNanocuries(QuantityValue nanocuries)
+        public static Radioactivity FromNanocuries(double nanocuries)
         {
-            double value = (double) nanocuries;
-            return new Radioactivity(value, RadioactivityUnit.Nanocurie);
+            return new Radioactivity(nanocuries, RadioactivityUnit.Nanocurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanorutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromNanorutherfords(QuantityValue nanorutherfords)
+        public static Radioactivity FromNanorutherfords(double nanorutherfords)
         {
-            double value = (double) nanorutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Nanorutherford);
+            return new Radioactivity(nanorutherfords, RadioactivityUnit.Nanorutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Petabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromPetabecquerels(QuantityValue petabecquerels)
+        public static Radioactivity FromPetabecquerels(double petabecquerels)
         {
-            double value = (double) petabecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Petabecquerel);
+            return new Radioactivity(petabecquerels, RadioactivityUnit.Petabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picobecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromPicobecquerels(QuantityValue picobecquerels)
+        public static Radioactivity FromPicobecquerels(double picobecquerels)
         {
-            double value = (double) picobecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Picobecquerel);
+            return new Radioactivity(picobecquerels, RadioactivityUnit.Picobecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picocurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromPicocuries(QuantityValue picocuries)
+        public static Radioactivity FromPicocuries(double picocuries)
         {
-            double value = (double) picocuries;
-            return new Radioactivity(value, RadioactivityUnit.Picocurie);
+            return new Radioactivity(picocuries, RadioactivityUnit.Picocurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picorutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromPicorutherfords(QuantityValue picorutherfords)
+        public static Radioactivity FromPicorutherfords(double picorutherfords)
         {
-            double value = (double) picorutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Picorutherford);
+            return new Radioactivity(picorutherfords, RadioactivityUnit.Picorutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Rutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromRutherfords(QuantityValue rutherfords)
+        public static Radioactivity FromRutherfords(double rutherfords)
         {
-            double value = (double) rutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Rutherford);
+            return new Radioactivity(rutherfords, RadioactivityUnit.Rutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Terabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromTerabecquerels(QuantityValue terabecquerels)
+        public static Radioactivity FromTerabecquerels(double terabecquerels)
         {
-            double value = (double) terabecquerels;
-            return new Radioactivity(value, RadioactivityUnit.Terabecquerel);
+            return new Radioactivity(terabecquerels, RadioactivityUnit.Terabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Teracurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromTeracuries(QuantityValue teracuries)
+        public static Radioactivity FromTeracuries(double teracuries)
         {
-            double value = (double) teracuries;
-            return new Radioactivity(value, RadioactivityUnit.Teracurie);
+            return new Radioactivity(teracuries, RadioactivityUnit.Teracurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Terarutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromTerarutherfords(QuantityValue terarutherfords)
+        public static Radioactivity FromTerarutherfords(double terarutherfords)
         {
-            double value = (double) terarutherfords;
-            return new Radioactivity(value, RadioactivityUnit.Terarutherford);
+            return new Radioactivity(terarutherfords, RadioactivityUnit.Terarutherford);
         }
 
         /// <summary>
@@ -737,9 +708,9 @@ public static Radioactivity FromTerarutherfords(QuantityValue terarutherfords)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Radioactivity unit value.</returns>
-        public static Radioactivity From(QuantityValue value, RadioactivityUnit fromUnit)
+        public static Radioactivity From(double value, RadioactivityUnit fromUnit)
         {
-            return new Radioactivity((double)value, fromUnit);
+            return new Radioactivity(value, fromUnit);
         }
 
         #endregion
@@ -1150,15 +1121,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RadioactivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadioactivityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RadioactivityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadioactivityUnit)} is supported.", nameof(unit));
@@ -1329,18 +1291,6 @@ public Radioactivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RadioactivityUnit> IQuantity<RadioactivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RadioactivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RadioactivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
index d2e473b6f0..9ddb15bc47 100644
--- a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Ratio :
-        IArithmeticQuantity<Ratio, RatioUnit, double>,
+        IArithmeticQuantity<Ratio, RatioUnit>,
         IComparable,
         IComparable<Ratio>,
         IConvertible,
@@ -152,7 +152,7 @@ public Ratio(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -261,60 +261,54 @@ public static string GetAbbreviation(RatioUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.DecimalFraction"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromDecimalFractions(QuantityValue decimalfractions)
+        public static Ratio FromDecimalFractions(double decimalfractions)
         {
-            double value = (double) decimalfractions;
-            return new Ratio(value, RatioUnit.DecimalFraction);
+            return new Ratio(decimalfractions, RatioUnit.DecimalFraction);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerBillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerBillion(QuantityValue partsperbillion)
+        public static Ratio FromPartsPerBillion(double partsperbillion)
         {
-            double value = (double) partsperbillion;
-            return new Ratio(value, RatioUnit.PartPerBillion);
+            return new Ratio(partsperbillion, RatioUnit.PartPerBillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerMillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerMillion(QuantityValue partspermillion)
+        public static Ratio FromPartsPerMillion(double partspermillion)
         {
-            double value = (double) partspermillion;
-            return new Ratio(value, RatioUnit.PartPerMillion);
+            return new Ratio(partspermillion, RatioUnit.PartPerMillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerThousand"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerThousand(QuantityValue partsperthousand)
+        public static Ratio FromPartsPerThousand(double partsperthousand)
         {
-            double value = (double) partsperthousand;
-            return new Ratio(value, RatioUnit.PartPerThousand);
+            return new Ratio(partsperthousand, RatioUnit.PartPerThousand);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerTrillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerTrillion(QuantityValue partspertrillion)
+        public static Ratio FromPartsPerTrillion(double partspertrillion)
         {
-            double value = (double) partspertrillion;
-            return new Ratio(value, RatioUnit.PartPerTrillion);
+            return new Ratio(partspertrillion, RatioUnit.PartPerTrillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.Percent"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPercent(QuantityValue percent)
+        public static Ratio FromPercent(double percent)
         {
-            double value = (double) percent;
-            return new Ratio(value, RatioUnit.Percent);
+            return new Ratio(percent, RatioUnit.Percent);
         }
 
         /// <summary>
@@ -323,9 +317,9 @@ public static Ratio FromPercent(QuantityValue percent)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Ratio unit value.</returns>
-        public static Ratio From(QuantityValue value, RatioUnit fromUnit)
+        public static Ratio From(double value, RatioUnit fromUnit)
         {
-            return new Ratio((double)value, fromUnit);
+            return new Ratio(value, fromUnit);
         }
 
         #endregion
@@ -736,15 +730,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RatioUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RatioUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioUnit)} is supported.", nameof(unit));
@@ -869,18 +854,6 @@ public Ratio ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RatioUnit> IQuantity<RatioUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RatioUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
index fff23fbc87..913a13decd 100644
--- a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct RatioChangeRate :
-        IArithmeticQuantity<RatioChangeRate, RatioChangeRateUnit, double>,
+        IArithmeticQuantity<RatioChangeRate, RatioChangeRateUnit>,
         IComparable,
         IComparable<RatioChangeRate>,
         IConvertible,
@@ -148,7 +148,7 @@ public RatioChangeRate(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -229,20 +229,18 @@ public static string GetAbbreviation(RatioChangeRateUnit unit, IFormatProvider?
         ///     Creates a <see cref="RatioChangeRate"/> from <see cref="RatioChangeRateUnit.DecimalFractionPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RatioChangeRate FromDecimalFractionsPerSecond(QuantityValue decimalfractionspersecond)
+        public static RatioChangeRate FromDecimalFractionsPerSecond(double decimalfractionspersecond)
         {
-            double value = (double) decimalfractionspersecond;
-            return new RatioChangeRate(value, RatioChangeRateUnit.DecimalFractionPerSecond);
+            return new RatioChangeRate(decimalfractionspersecond, RatioChangeRateUnit.DecimalFractionPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RatioChangeRate"/> from <see cref="RatioChangeRateUnit.PercentPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RatioChangeRate FromPercentsPerSecond(QuantityValue percentspersecond)
+        public static RatioChangeRate FromPercentsPerSecond(double percentspersecond)
         {
-            double value = (double) percentspersecond;
-            return new RatioChangeRate(value, RatioChangeRateUnit.PercentPerSecond);
+            return new RatioChangeRate(percentspersecond, RatioChangeRateUnit.PercentPerSecond);
         }
 
         /// <summary>
@@ -251,9 +249,9 @@ public static RatioChangeRate FromPercentsPerSecond(QuantityValue percentspersec
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RatioChangeRate unit value.</returns>
-        public static RatioChangeRate From(QuantityValue value, RatioChangeRateUnit fromUnit)
+        public static RatioChangeRate From(double value, RatioChangeRateUnit fromUnit)
         {
-            return new RatioChangeRate((double)value, fromUnit);
+            return new RatioChangeRate(value, fromUnit);
         }
 
         #endregion
@@ -664,15 +662,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RatioChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioChangeRateUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RatioChangeRateUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioChangeRateUnit)} is supported.", nameof(unit));
@@ -789,18 +778,6 @@ public RatioChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RatioChangeRateUnit> IQuantity<RatioChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RatioChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RatioChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
index 7078170d8f..4da15c9eb7 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ReactiveEnergy :
-        IArithmeticQuantity<ReactiveEnergy, ReactiveEnergyUnit, double>,
+        IArithmeticQuantity<ReactiveEnergy, ReactiveEnergyUnit>,
         IComparable,
         IComparable<ReactiveEnergy>,
         IConvertible,
@@ -149,7 +149,7 @@ public ReactiveEnergy(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -237,30 +237,27 @@ public static string GetAbbreviation(ReactiveEnergyUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ReactiveEnergy"/> from <see cref="ReactiveEnergyUnit.KilovoltampereReactiveHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromKilovoltampereReactiveHours(QuantityValue kilovoltamperereactivehours)
+        public static ReactiveEnergy FromKilovoltampereReactiveHours(double kilovoltamperereactivehours)
         {
-            double value = (double) kilovoltamperereactivehours;
-            return new ReactiveEnergy(value, ReactiveEnergyUnit.KilovoltampereReactiveHour);
+            return new ReactiveEnergy(kilovoltamperereactivehours, ReactiveEnergyUnit.KilovoltampereReactiveHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactiveEnergy"/> from <see cref="ReactiveEnergyUnit.MegavoltampereReactiveHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromMegavoltampereReactiveHours(QuantityValue megavoltamperereactivehours)
+        public static ReactiveEnergy FromMegavoltampereReactiveHours(double megavoltamperereactivehours)
         {
-            double value = (double) megavoltamperereactivehours;
-            return new ReactiveEnergy(value, ReactiveEnergyUnit.MegavoltampereReactiveHour);
+            return new ReactiveEnergy(megavoltamperereactivehours, ReactiveEnergyUnit.MegavoltampereReactiveHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactiveEnergy"/> from <see cref="ReactiveEnergyUnit.VoltampereReactiveHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromVoltampereReactiveHours(QuantityValue voltamperereactivehours)
+        public static ReactiveEnergy FromVoltampereReactiveHours(double voltamperereactivehours)
         {
-            double value = (double) voltamperereactivehours;
-            return new ReactiveEnergy(value, ReactiveEnergyUnit.VoltampereReactiveHour);
+            return new ReactiveEnergy(voltamperereactivehours, ReactiveEnergyUnit.VoltampereReactiveHour);
         }
 
         /// <summary>
@@ -269,9 +266,9 @@ public static ReactiveEnergy FromVoltampereReactiveHours(QuantityValue voltamper
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ReactiveEnergy unit value.</returns>
-        public static ReactiveEnergy From(QuantityValue value, ReactiveEnergyUnit fromUnit)
+        public static ReactiveEnergy From(double value, ReactiveEnergyUnit fromUnit)
         {
-            return new ReactiveEnergy((double)value, fromUnit);
+            return new ReactiveEnergy(value, fromUnit);
         }
 
         #endregion
@@ -682,15 +679,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ReactiveEnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReactiveEnergyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ReactiveEnergyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReactiveEnergyUnit)} is supported.", nameof(unit));
@@ -809,18 +797,6 @@ public ReactiveEnergy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ReactiveEnergyUnit> IQuantity<ReactiveEnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ReactiveEnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReactiveEnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
index eb13dc9ce0..f25c534690 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ReactivePower :
-        IArithmeticQuantity<ReactivePower, ReactivePowerUnit, double>,
+        IArithmeticQuantity<ReactivePower, ReactivePowerUnit>,
         IComparable,
         IComparable<ReactivePower>,
         IConvertible,
@@ -150,7 +150,7 @@ public ReactivePower(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -245,40 +245,36 @@ public static string GetAbbreviation(ReactivePowerUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="ReactivePower"/> from <see cref="ReactivePowerUnit.GigavoltampereReactive"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromGigavoltamperesReactive(QuantityValue gigavoltamperesreactive)
+        public static ReactivePower FromGigavoltamperesReactive(double gigavoltamperesreactive)
         {
-            double value = (double) gigavoltamperesreactive;
-            return new ReactivePower(value, ReactivePowerUnit.GigavoltampereReactive);
+            return new ReactivePower(gigavoltamperesreactive, ReactivePowerUnit.GigavoltampereReactive);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactivePower"/> from <see cref="ReactivePowerUnit.KilovoltampereReactive"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromKilovoltamperesReactive(QuantityValue kilovoltamperesreactive)
+        public static ReactivePower FromKilovoltamperesReactive(double kilovoltamperesreactive)
         {
-            double value = (double) kilovoltamperesreactive;
-            return new ReactivePower(value, ReactivePowerUnit.KilovoltampereReactive);
+            return new ReactivePower(kilovoltamperesreactive, ReactivePowerUnit.KilovoltampereReactive);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactivePower"/> from <see cref="ReactivePowerUnit.MegavoltampereReactive"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromMegavoltamperesReactive(QuantityValue megavoltamperesreactive)
+        public static ReactivePower FromMegavoltamperesReactive(double megavoltamperesreactive)
         {
-            double value = (double) megavoltamperesreactive;
-            return new ReactivePower(value, ReactivePowerUnit.MegavoltampereReactive);
+            return new ReactivePower(megavoltamperesreactive, ReactivePowerUnit.MegavoltampereReactive);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactivePower"/> from <see cref="ReactivePowerUnit.VoltampereReactive"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromVoltamperesReactive(QuantityValue voltamperesreactive)
+        public static ReactivePower FromVoltamperesReactive(double voltamperesreactive)
         {
-            double value = (double) voltamperesreactive;
-            return new ReactivePower(value, ReactivePowerUnit.VoltampereReactive);
+            return new ReactivePower(voltamperesreactive, ReactivePowerUnit.VoltampereReactive);
         }
 
         /// <summary>
@@ -287,9 +283,9 @@ public static ReactivePower FromVoltamperesReactive(QuantityValue voltamperesrea
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ReactivePower unit value.</returns>
-        public static ReactivePower From(QuantityValue value, ReactivePowerUnit fromUnit)
+        public static ReactivePower From(double value, ReactivePowerUnit fromUnit)
         {
-            return new ReactivePower((double)value, fromUnit);
+            return new ReactivePower(value, fromUnit);
         }
 
         #endregion
@@ -700,15 +696,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ReactivePowerUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReactivePowerUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ReactivePowerUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReactivePowerUnit)} is supported.", nameof(unit));
@@ -829,18 +816,6 @@ public ReactivePower ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ReactivePowerUnit> IQuantity<ReactivePowerUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ReactivePowerUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReactivePowerUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
index 33af7f257e..4ffad89940 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ReciprocalArea :
-        IArithmeticQuantity<ReciprocalArea, ReciprocalAreaUnit, double>,
+        IArithmeticQuantity<ReciprocalArea, ReciprocalAreaUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<ReciprocalArea, Force, Pressure>,
         IMultiplyOperators<ReciprocalArea, Area, Ratio>,
@@ -168,7 +168,7 @@ public ReciprocalArea(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -312,110 +312,99 @@ public static string GetAbbreviation(ReciprocalAreaUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareCentimeters(QuantityValue inversesquarecentimeters)
+        public static ReciprocalArea FromInverseSquareCentimeters(double inversesquarecentimeters)
         {
-            double value = (double) inversesquarecentimeters;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter);
+            return new ReciprocalArea(inversesquarecentimeters, ReciprocalAreaUnit.InverseSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareDecimeters(QuantityValue inversesquaredecimeters)
+        public static ReciprocalArea FromInverseSquareDecimeters(double inversesquaredecimeters)
         {
-            double value = (double) inversesquaredecimeters;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter);
+            return new ReciprocalArea(inversesquaredecimeters, ReciprocalAreaUnit.InverseSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareFeet(QuantityValue inversesquarefeet)
+        public static ReciprocalArea FromInverseSquareFeet(double inversesquarefeet)
         {
-            double value = (double) inversesquarefeet;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot);
+            return new ReciprocalArea(inversesquarefeet, ReciprocalAreaUnit.InverseSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareInches(QuantityValue inversesquareinches)
+        public static ReciprocalArea FromInverseSquareInches(double inversesquareinches)
         {
-            double value = (double) inversesquareinches;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch);
+            return new ReciprocalArea(inversesquareinches, ReciprocalAreaUnit.InverseSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareKilometers(QuantityValue inversesquarekilometers)
+        public static ReciprocalArea FromInverseSquareKilometers(double inversesquarekilometers)
         {
-            double value = (double) inversesquarekilometers;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer);
+            return new ReciprocalArea(inversesquarekilometers, ReciprocalAreaUnit.InverseSquareKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareMeters(QuantityValue inversesquaremeters)
+        public static ReciprocalArea FromInverseSquareMeters(double inversesquaremeters)
         {
-            double value = (double) inversesquaremeters;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter);
+            return new ReciprocalArea(inversesquaremeters, ReciprocalAreaUnit.InverseSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMicrometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareMicrometers(QuantityValue inversesquaremicrometers)
+        public static ReciprocalArea FromInverseSquareMicrometers(double inversesquaremicrometers)
         {
-            double value = (double) inversesquaremicrometers;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer);
+            return new ReciprocalArea(inversesquaremicrometers, ReciprocalAreaUnit.InverseSquareMicrometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareMiles(QuantityValue inversesquaremiles)
+        public static ReciprocalArea FromInverseSquareMiles(double inversesquaremiles)
         {
-            double value = (double) inversesquaremiles;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile);
+            return new ReciprocalArea(inversesquaremiles, ReciprocalAreaUnit.InverseSquareMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareMillimeters(QuantityValue inversesquaremillimeters)
+        public static ReciprocalArea FromInverseSquareMillimeters(double inversesquaremillimeters)
         {
-            double value = (double) inversesquaremillimeters;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter);
+            return new ReciprocalArea(inversesquaremillimeters, ReciprocalAreaUnit.InverseSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareYards(QuantityValue inversesquareyards)
+        public static ReciprocalArea FromInverseSquareYards(double inversesquareyards)
         {
-            double value = (double) inversesquareyards;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard);
+            return new ReciprocalArea(inversesquareyards, ReciprocalAreaUnit.InverseSquareYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseUsSurveySquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseUsSurveySquareFeet(QuantityValue inverseussurveysquarefeet)
+        public static ReciprocalArea FromInverseUsSurveySquareFeet(double inverseussurveysquarefeet)
         {
-            double value = (double) inverseussurveysquarefeet;
-            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot);
+            return new ReciprocalArea(inverseussurveysquarefeet, ReciprocalAreaUnit.InverseUsSurveySquareFoot);
         }
 
         /// <summary>
@@ -424,9 +413,9 @@ public static ReciprocalArea FromInverseUsSurveySquareFeet(QuantityValue inverse
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ReciprocalArea unit value.</returns>
-        public static ReciprocalArea From(QuantityValue value, ReciprocalAreaUnit fromUnit)
+        public static ReciprocalArea From(double value, ReciprocalAreaUnit fromUnit)
         {
-            return new ReciprocalArea((double)value, fromUnit);
+            return new ReciprocalArea(value, fromUnit);
         }
 
         #endregion
@@ -866,15 +855,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ReciprocalAreaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalAreaUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ReciprocalAreaUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalAreaUnit)} is supported.", nameof(unit));
@@ -1009,18 +989,6 @@ public ReciprocalArea ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ReciprocalAreaUnit> IQuantity<ReciprocalAreaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ReciprocalAreaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalAreaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
index e7e14092e9..e980cebee2 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ReciprocalLength :
-        IArithmeticQuantity<ReciprocalLength, ReciprocalLengthUnit, double>,
+        IArithmeticQuantity<ReciprocalLength, ReciprocalLengthUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<ReciprocalLength, Force, ForcePerLength>,
         IDivisionOperators<ReciprocalLength, ReciprocalArea, Length>,
@@ -168,7 +168,7 @@ public ReciprocalLength(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -305,100 +305,90 @@ public static string GetAbbreviation(ReciprocalLengthUnit unit, IFormatProvider?
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseCentimeters(QuantityValue inversecentimeters)
+        public static ReciprocalLength FromInverseCentimeters(double inversecentimeters)
         {
-            double value = (double) inversecentimeters;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseCentimeter);
+            return new ReciprocalLength(inversecentimeters, ReciprocalLengthUnit.InverseCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseFeet(QuantityValue inversefeet)
+        public static ReciprocalLength FromInverseFeet(double inversefeet)
         {
-            double value = (double) inversefeet;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseFoot);
+            return new ReciprocalLength(inversefeet, ReciprocalLengthUnit.InverseFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseInches(QuantityValue inverseinches)
+        public static ReciprocalLength FromInverseInches(double inverseinches)
         {
-            double value = (double) inverseinches;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseInch);
+            return new ReciprocalLength(inverseinches, ReciprocalLengthUnit.InverseInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMeters(QuantityValue inversemeters)
+        public static ReciprocalLength FromInverseMeters(double inversemeters)
         {
-            double value = (double) inversemeters;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter);
+            return new ReciprocalLength(inversemeters, ReciprocalLengthUnit.InverseMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMicroinch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMicroinches(QuantityValue inversemicroinches)
+        public static ReciprocalLength FromInverseMicroinches(double inversemicroinches)
         {
-            double value = (double) inversemicroinches;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMicroinch);
+            return new ReciprocalLength(inversemicroinches, ReciprocalLengthUnit.InverseMicroinch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMils(QuantityValue inversemils)
+        public static ReciprocalLength FromInverseMils(double inversemils)
         {
-            double value = (double) inversemils;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMil);
+            return new ReciprocalLength(inversemils, ReciprocalLengthUnit.InverseMil);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMiles(QuantityValue inversemiles)
+        public static ReciprocalLength FromInverseMiles(double inversemiles)
         {
-            double value = (double) inversemiles;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMile);
+            return new ReciprocalLength(inversemiles, ReciprocalLengthUnit.InverseMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMillimeters(QuantityValue inversemillimeters)
+        public static ReciprocalLength FromInverseMillimeters(double inversemillimeters)
         {
-            double value = (double) inversemillimeters;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMillimeter);
+            return new ReciprocalLength(inversemillimeters, ReciprocalLengthUnit.InverseMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseUsSurveyFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseUsSurveyFeet(QuantityValue inverseussurveyfeet)
+        public static ReciprocalLength FromInverseUsSurveyFeet(double inverseussurveyfeet)
         {
-            double value = (double) inverseussurveyfeet;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseUsSurveyFoot);
+            return new ReciprocalLength(inverseussurveyfeet, ReciprocalLengthUnit.InverseUsSurveyFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseYards(QuantityValue inverseyards)
+        public static ReciprocalLength FromInverseYards(double inverseyards)
         {
-            double value = (double) inverseyards;
-            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseYard);
+            return new ReciprocalLength(inverseyards, ReciprocalLengthUnit.InverseYard);
         }
 
         /// <summary>
@@ -407,9 +397,9 @@ public static ReciprocalLength FromInverseYards(QuantityValue inverseyards)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ReciprocalLength unit value.</returns>
-        public static ReciprocalLength From(QuantityValue value, ReciprocalLengthUnit fromUnit)
+        public static ReciprocalLength From(double value, ReciprocalLengthUnit fromUnit)
         {
-            return new ReciprocalLength((double)value, fromUnit);
+            return new ReciprocalLength(value, fromUnit);
         }
 
         #endregion
@@ -855,15 +845,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ReciprocalLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalLengthUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ReciprocalLengthUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalLengthUnit)} is supported.", nameof(unit));
@@ -996,18 +977,6 @@ public ReciprocalLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ReciprocalLengthUnit> IQuantity<ReciprocalLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ReciprocalLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ReciprocalLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
index e40d9a2225..c66c66a8ea 100644
--- a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct RelativeHumidity :
-        IArithmeticQuantity<RelativeHumidity, RelativeHumidityUnit, double>,
+        IArithmeticQuantity<RelativeHumidity, RelativeHumidityUnit>,
         IComparable,
         IComparable<RelativeHumidity>,
         IConvertible,
@@ -147,7 +147,7 @@ public RelativeHumidity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -221,10 +221,9 @@ public static string GetAbbreviation(RelativeHumidityUnit unit, IFormatProvider?
         ///     Creates a <see cref="RelativeHumidity"/> from <see cref="RelativeHumidityUnit.Percent"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RelativeHumidity FromPercent(QuantityValue percent)
+        public static RelativeHumidity FromPercent(double percent)
         {
-            double value = (double) percent;
-            return new RelativeHumidity(value, RelativeHumidityUnit.Percent);
+            return new RelativeHumidity(percent, RelativeHumidityUnit.Percent);
         }
 
         /// <summary>
@@ -233,9 +232,9 @@ public static RelativeHumidity FromPercent(QuantityValue percent)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RelativeHumidity unit value.</returns>
-        public static RelativeHumidity From(QuantityValue value, RelativeHumidityUnit fromUnit)
+        public static RelativeHumidity From(double value, RelativeHumidityUnit fromUnit)
         {
-            return new RelativeHumidity((double)value, fromUnit);
+            return new RelativeHumidity(value, fromUnit);
         }
 
         #endregion
@@ -646,15 +645,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RelativeHumidityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RelativeHumidityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RelativeHumidityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RelativeHumidityUnit)} is supported.", nameof(unit));
@@ -769,18 +759,6 @@ public RelativeHumidity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RelativeHumidityUnit> IQuantity<RelativeHumidityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RelativeHumidityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RelativeHumidityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
index 69d92b62ea..2131f06cbd 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct RotationalAcceleration :
-        IArithmeticQuantity<RotationalAcceleration, RotationalAccelerationUnit, double>,
+        IArithmeticQuantity<RotationalAcceleration, RotationalAccelerationUnit>,
         IComparable,
         IComparable<RotationalAcceleration>,
         IConvertible,
@@ -150,7 +150,7 @@ public RotationalAcceleration(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -245,40 +245,36 @@ public static string GetAbbreviation(RotationalAccelerationUnit unit, IFormatPro
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.DegreePerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromDegreesPerSecondSquared(QuantityValue degreespersecondsquared)
+        public static RotationalAcceleration FromDegreesPerSecondSquared(double degreespersecondsquared)
         {
-            double value = (double) degreespersecondsquared;
-            return new RotationalAcceleration(value, RotationalAccelerationUnit.DegreePerSecondSquared);
+            return new RotationalAcceleration(degreespersecondsquared, RotationalAccelerationUnit.DegreePerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RadianPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRadiansPerSecondSquared(QuantityValue radianspersecondsquared)
+        public static RotationalAcceleration FromRadiansPerSecondSquared(double radianspersecondsquared)
         {
-            double value = (double) radianspersecondsquared;
-            return new RotationalAcceleration(value, RotationalAccelerationUnit.RadianPerSecondSquared);
+            return new RotationalAcceleration(radianspersecondsquared, RotationalAccelerationUnit.RadianPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RevolutionPerMinutePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(QuantityValue revolutionsperminutepersecond)
+        public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(double revolutionsperminutepersecond)
         {
-            double value = (double) revolutionsperminutepersecond;
-            return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
+            return new RotationalAcceleration(revolutionsperminutepersecond, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RevolutionPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRevolutionsPerSecondSquared(QuantityValue revolutionspersecondsquared)
+        public static RotationalAcceleration FromRevolutionsPerSecondSquared(double revolutionspersecondsquared)
         {
-            double value = (double) revolutionspersecondsquared;
-            return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerSecondSquared);
+            return new RotationalAcceleration(revolutionspersecondsquared, RotationalAccelerationUnit.RevolutionPerSecondSquared);
         }
 
         /// <summary>
@@ -287,9 +283,9 @@ public static RotationalAcceleration FromRevolutionsPerSecondSquared(QuantityVal
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RotationalAcceleration unit value.</returns>
-        public static RotationalAcceleration From(QuantityValue value, RotationalAccelerationUnit fromUnit)
+        public static RotationalAcceleration From(double value, RotationalAccelerationUnit fromUnit)
         {
-            return new RotationalAcceleration((double)value, fromUnit);
+            return new RotationalAcceleration(value, fromUnit);
         }
 
         #endregion
@@ -700,15 +696,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RotationalAccelerationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalAccelerationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RotationalAccelerationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalAccelerationUnit)} is supported.", nameof(unit));
@@ -829,18 +816,6 @@ public RotationalAcceleration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RotationalAccelerationUnit> IQuantity<RotationalAccelerationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RotationalAccelerationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalAccelerationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
index 72fb597d12..3a0bb6bc99 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct RotationalSpeed :
-        IArithmeticQuantity<RotationalSpeed, RotationalSpeedUnit, double>,
+        IArithmeticQuantity<RotationalSpeed, RotationalSpeedUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<RotationalSpeed, Duration, Angle>,
         IMultiplyOperators<RotationalSpeed, TimeSpan, Angle>,
@@ -166,7 +166,7 @@ public RotationalSpeed(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -324,130 +324,117 @@ public static string GetAbbreviation(RotationalSpeedUnit unit, IFormatProvider?
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.CentiradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromCentiradiansPerSecond(QuantityValue centiradianspersecond)
+        public static RotationalSpeed FromCentiradiansPerSecond(double centiradianspersecond)
         {
-            double value = (double) centiradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.CentiradianPerSecond);
+            return new RotationalSpeed(centiradianspersecond, RotationalSpeedUnit.CentiradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DeciradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDeciradiansPerSecond(QuantityValue deciradianspersecond)
+        public static RotationalSpeed FromDeciradiansPerSecond(double deciradianspersecond)
         {
-            double value = (double) deciradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.DeciradianPerSecond);
+            return new RotationalSpeed(deciradianspersecond, RotationalSpeedUnit.DeciradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DegreePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDegreesPerMinute(QuantityValue degreesperminute)
+        public static RotationalSpeed FromDegreesPerMinute(double degreesperminute)
         {
-            double value = (double) degreesperminute;
-            return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerMinute);
+            return new RotationalSpeed(degreesperminute, RotationalSpeedUnit.DegreePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DegreePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDegreesPerSecond(QuantityValue degreespersecond)
+        public static RotationalSpeed FromDegreesPerSecond(double degreespersecond)
         {
-            double value = (double) degreespersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerSecond);
+            return new RotationalSpeed(degreespersecond, RotationalSpeedUnit.DegreePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MicrodegreePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMicrodegreesPerSecond(QuantityValue microdegreespersecond)
+        public static RotationalSpeed FromMicrodegreesPerSecond(double microdegreespersecond)
         {
-            double value = (double) microdegreespersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.MicrodegreePerSecond);
+            return new RotationalSpeed(microdegreespersecond, RotationalSpeedUnit.MicrodegreePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MicroradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMicroradiansPerSecond(QuantityValue microradianspersecond)
+        public static RotationalSpeed FromMicroradiansPerSecond(double microradianspersecond)
         {
-            double value = (double) microradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.MicroradianPerSecond);
+            return new RotationalSpeed(microradianspersecond, RotationalSpeedUnit.MicroradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MillidegreePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMillidegreesPerSecond(QuantityValue millidegreespersecond)
+        public static RotationalSpeed FromMillidegreesPerSecond(double millidegreespersecond)
         {
-            double value = (double) millidegreespersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.MillidegreePerSecond);
+            return new RotationalSpeed(millidegreespersecond, RotationalSpeedUnit.MillidegreePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MilliradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMilliradiansPerSecond(QuantityValue milliradianspersecond)
+        public static RotationalSpeed FromMilliradiansPerSecond(double milliradianspersecond)
         {
-            double value = (double) milliradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.MilliradianPerSecond);
+            return new RotationalSpeed(milliradianspersecond, RotationalSpeedUnit.MilliradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.NanodegreePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromNanodegreesPerSecond(QuantityValue nanodegreespersecond)
+        public static RotationalSpeed FromNanodegreesPerSecond(double nanodegreespersecond)
         {
-            double value = (double) nanodegreespersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.NanodegreePerSecond);
+            return new RotationalSpeed(nanodegreespersecond, RotationalSpeedUnit.NanodegreePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.NanoradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromNanoradiansPerSecond(QuantityValue nanoradianspersecond)
+        public static RotationalSpeed FromNanoradiansPerSecond(double nanoradianspersecond)
         {
-            double value = (double) nanoradianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.NanoradianPerSecond);
+            return new RotationalSpeed(nanoradianspersecond, RotationalSpeedUnit.NanoradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RadianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRadiansPerSecond(QuantityValue radianspersecond)
+        public static RotationalSpeed FromRadiansPerSecond(double radianspersecond)
         {
-            double value = (double) radianspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.RadianPerSecond);
+            return new RotationalSpeed(radianspersecond, RotationalSpeedUnit.RadianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RevolutionPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRevolutionsPerMinute(QuantityValue revolutionsperminute)
+        public static RotationalSpeed FromRevolutionsPerMinute(double revolutionsperminute)
         {
-            double value = (double) revolutionsperminute;
-            return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerMinute);
+            return new RotationalSpeed(revolutionsperminute, RotationalSpeedUnit.RevolutionPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RevolutionPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRevolutionsPerSecond(QuantityValue revolutionspersecond)
+        public static RotationalSpeed FromRevolutionsPerSecond(double revolutionspersecond)
         {
-            double value = (double) revolutionspersecond;
-            return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerSecond);
+            return new RotationalSpeed(revolutionspersecond, RotationalSpeedUnit.RevolutionPerSecond);
         }
 
         /// <summary>
@@ -456,9 +443,9 @@ public static RotationalSpeed FromRevolutionsPerSecond(QuantityValue revolutions
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RotationalSpeed unit value.</returns>
-        public static RotationalSpeed From(QuantityValue value, RotationalSpeedUnit fromUnit)
+        public static RotationalSpeed From(double value, RotationalSpeedUnit fromUnit)
         {
-            return new RotationalSpeed((double)value, fromUnit);
+            return new RotationalSpeed(value, fromUnit);
         }
 
         #endregion
@@ -891,15 +878,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RotationalSpeedUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalSpeedUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RotationalSpeedUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalSpeedUnit)} is supported.", nameof(unit));
@@ -1038,18 +1016,6 @@ public RotationalSpeed ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RotationalSpeedUnit> IQuantity<RotationalSpeedUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RotationalSpeedUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalSpeedUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
index cba3bee86f..e6ed3b465c 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct RotationalStiffness :
-        IArithmeticQuantity<RotationalStiffness, RotationalStiffnessUnit, double>,
+        IArithmeticQuantity<RotationalStiffness, RotationalStiffnessUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<RotationalStiffness, RotationalStiffnessPerLength, Length>,
         IDivisionOperators<RotationalStiffness, Length, RotationalStiffnessPerLength>,
@@ -187,7 +187,7 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -485,330 +485,297 @@ public static string GetAbbreviation(RotationalStiffnessUnit unit, IFormatProvid
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMetersPerDegree(QuantityValue centinewtonmetersperdegree)
+        public static RotationalStiffness FromCentinewtonMetersPerDegree(double centinewtonmetersperdegree)
         {
-            double value = (double) centinewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
+            return new RotationalStiffness(centinewtonmetersperdegree, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMillimetersPerDegree(QuantityValue centinewtonmillimetersperdegree)
+        public static RotationalStiffness FromCentinewtonMillimetersPerDegree(double centinewtonmillimetersperdegree)
         {
-            double value = (double) centinewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
+            return new RotationalStiffness(centinewtonmillimetersperdegree, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMillimetersPerRadian(QuantityValue centinewtonmillimetersperradian)
+        public static RotationalStiffness FromCentinewtonMillimetersPerRadian(double centinewtonmillimetersperradian)
         {
-            double value = (double) centinewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
+            return new RotationalStiffness(centinewtonmillimetersperradian, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMetersPerDegree(QuantityValue decanewtonmetersperdegree)
+        public static RotationalStiffness FromDecanewtonMetersPerDegree(double decanewtonmetersperdegree)
         {
-            double value = (double) decanewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
+            return new RotationalStiffness(decanewtonmetersperdegree, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMillimetersPerDegree(QuantityValue decanewtonmillimetersperdegree)
+        public static RotationalStiffness FromDecanewtonMillimetersPerDegree(double decanewtonmillimetersperdegree)
         {
-            double value = (double) decanewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
+            return new RotationalStiffness(decanewtonmillimetersperdegree, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMillimetersPerRadian(QuantityValue decanewtonmillimetersperradian)
+        public static RotationalStiffness FromDecanewtonMillimetersPerRadian(double decanewtonmillimetersperradian)
         {
-            double value = (double) decanewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
+            return new RotationalStiffness(decanewtonmillimetersperradian, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMetersPerDegree(QuantityValue decinewtonmetersperdegree)
+        public static RotationalStiffness FromDecinewtonMetersPerDegree(double decinewtonmetersperdegree)
         {
-            double value = (double) decinewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
+            return new RotationalStiffness(decinewtonmetersperdegree, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMillimetersPerDegree(QuantityValue decinewtonmillimetersperdegree)
+        public static RotationalStiffness FromDecinewtonMillimetersPerDegree(double decinewtonmillimetersperdegree)
         {
-            double value = (double) decinewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
+            return new RotationalStiffness(decinewtonmillimetersperdegree, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMillimetersPerRadian(QuantityValue decinewtonmillimetersperradian)
+        public static RotationalStiffness FromDecinewtonMillimetersPerRadian(double decinewtonmillimetersperradian)
         {
-            double value = (double) decinewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
+            return new RotationalStiffness(decinewtonmillimetersperradian, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMetersPerDegree(QuantityValue kilonewtonmetersperdegree)
+        public static RotationalStiffness FromKilonewtonMetersPerDegree(double kilonewtonmetersperdegree)
         {
-            double value = (double) kilonewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
+            return new RotationalStiffness(kilonewtonmetersperdegree, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMetersPerRadian(QuantityValue kilonewtonmetersperradian)
+        public static RotationalStiffness FromKilonewtonMetersPerRadian(double kilonewtonmetersperradian)
         {
-            double value = (double) kilonewtonmetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
+            return new RotationalStiffness(kilonewtonmetersperradian, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMillimetersPerDegree(QuantityValue kilonewtonmillimetersperdegree)
+        public static RotationalStiffness FromKilonewtonMillimetersPerDegree(double kilonewtonmillimetersperdegree)
         {
-            double value = (double) kilonewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
+            return new RotationalStiffness(kilonewtonmillimetersperdegree, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMillimetersPerRadian(QuantityValue kilonewtonmillimetersperradian)
+        public static RotationalStiffness FromKilonewtonMillimetersPerRadian(double kilonewtonmillimetersperradian)
         {
-            double value = (double) kilonewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
+            return new RotationalStiffness(kilonewtonmillimetersperradian, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilopoundForceFootPerDegrees"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(QuantityValue kilopoundforcefeetperdegrees)
+        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double kilopoundforcefeetperdegrees)
         {
-            double value = (double) kilopoundforcefeetperdegrees;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+            return new RotationalStiffness(kilopoundforcefeetperdegrees, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMetersPerDegree(QuantityValue meganewtonmetersperdegree)
+        public static RotationalStiffness FromMeganewtonMetersPerDegree(double meganewtonmetersperdegree)
         {
-            double value = (double) meganewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
+            return new RotationalStiffness(meganewtonmetersperdegree, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMetersPerRadian(QuantityValue meganewtonmetersperradian)
+        public static RotationalStiffness FromMeganewtonMetersPerRadian(double meganewtonmetersperradian)
         {
-            double value = (double) meganewtonmetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
+            return new RotationalStiffness(meganewtonmetersperradian, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMillimetersPerDegree(QuantityValue meganewtonmillimetersperdegree)
+        public static RotationalStiffness FromMeganewtonMillimetersPerDegree(double meganewtonmillimetersperdegree)
         {
-            double value = (double) meganewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
+            return new RotationalStiffness(meganewtonmillimetersperdegree, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMillimetersPerRadian(QuantityValue meganewtonmillimetersperradian)
+        public static RotationalStiffness FromMeganewtonMillimetersPerRadian(double meganewtonmillimetersperradian)
         {
-            double value = (double) meganewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
+            return new RotationalStiffness(meganewtonmillimetersperradian, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMetersPerDegree(QuantityValue micronewtonmetersperdegree)
+        public static RotationalStiffness FromMicronewtonMetersPerDegree(double micronewtonmetersperdegree)
         {
-            double value = (double) micronewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
+            return new RotationalStiffness(micronewtonmetersperdegree, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMillimetersPerDegree(QuantityValue micronewtonmillimetersperdegree)
+        public static RotationalStiffness FromMicronewtonMillimetersPerDegree(double micronewtonmillimetersperdegree)
         {
-            double value = (double) micronewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
+            return new RotationalStiffness(micronewtonmillimetersperdegree, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMillimetersPerRadian(QuantityValue micronewtonmillimetersperradian)
+        public static RotationalStiffness FromMicronewtonMillimetersPerRadian(double micronewtonmillimetersperradian)
         {
-            double value = (double) micronewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
+            return new RotationalStiffness(micronewtonmillimetersperradian, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMetersPerDegree(QuantityValue millinewtonmetersperdegree)
+        public static RotationalStiffness FromMillinewtonMetersPerDegree(double millinewtonmetersperdegree)
         {
-            double value = (double) millinewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
+            return new RotationalStiffness(millinewtonmetersperdegree, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMillimetersPerDegree(QuantityValue millinewtonmillimetersperdegree)
+        public static RotationalStiffness FromMillinewtonMillimetersPerDegree(double millinewtonmillimetersperdegree)
         {
-            double value = (double) millinewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
+            return new RotationalStiffness(millinewtonmillimetersperdegree, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMillimetersPerRadian(QuantityValue millinewtonmillimetersperradian)
+        public static RotationalStiffness FromMillinewtonMillimetersPerRadian(double millinewtonmillimetersperradian)
         {
-            double value = (double) millinewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
+            return new RotationalStiffness(millinewtonmillimetersperradian, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMetersPerDegree(QuantityValue nanonewtonmetersperdegree)
+        public static RotationalStiffness FromNanonewtonMetersPerDegree(double nanonewtonmetersperdegree)
         {
-            double value = (double) nanonewtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
+            return new RotationalStiffness(nanonewtonmetersperdegree, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMillimetersPerDegree(QuantityValue nanonewtonmillimetersperdegree)
+        public static RotationalStiffness FromNanonewtonMillimetersPerDegree(double nanonewtonmillimetersperdegree)
         {
-            double value = (double) nanonewtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
+            return new RotationalStiffness(nanonewtonmillimetersperdegree, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMillimetersPerRadian(QuantityValue nanonewtonmillimetersperradian)
+        public static RotationalStiffness FromNanonewtonMillimetersPerRadian(double nanonewtonmillimetersperradian)
         {
-            double value = (double) nanonewtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
+            return new RotationalStiffness(nanonewtonmillimetersperradian, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMetersPerDegree(QuantityValue newtonmetersperdegree)
+        public static RotationalStiffness FromNewtonMetersPerDegree(double newtonmetersperdegree)
         {
-            double value = (double) newtonmetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerDegree);
+            return new RotationalStiffness(newtonmetersperdegree, RotationalStiffnessUnit.NewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMetersPerRadian(QuantityValue newtonmetersperradian)
+        public static RotationalStiffness FromNewtonMetersPerRadian(double newtonmetersperradian)
         {
-            double value = (double) newtonmetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian);
+            return new RotationalStiffness(newtonmetersperradian, RotationalStiffnessUnit.NewtonMeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMillimetersPerDegree(QuantityValue newtonmillimetersperdegree)
+        public static RotationalStiffness FromNewtonMillimetersPerDegree(double newtonmillimetersperdegree)
         {
-            double value = (double) newtonmillimetersperdegree;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
+            return new RotationalStiffness(newtonmillimetersperdegree, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMillimetersPerRadian(QuantityValue newtonmillimetersperradian)
+        public static RotationalStiffness FromNewtonMillimetersPerRadian(double newtonmillimetersperradian)
         {
-            double value = (double) newtonmillimetersperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
+            return new RotationalStiffness(newtonmillimetersperradian, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.PoundForceFeetPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromPoundForceFeetPerRadian(QuantityValue poundforcefeetperradian)
+        public static RotationalStiffness FromPoundForceFeetPerRadian(double poundforcefeetperradian)
         {
-            double value = (double) poundforcefeetperradian;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFeetPerRadian);
+            return new RotationalStiffness(poundforcefeetperradian, RotationalStiffnessUnit.PoundForceFeetPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.PoundForceFootPerDegrees"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromPoundForceFeetPerDegrees(QuantityValue poundforcefeetperdegrees)
+        public static RotationalStiffness FromPoundForceFeetPerDegrees(double poundforcefeetperdegrees)
         {
-            double value = (double) poundforcefeetperdegrees;
-            return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees);
+            return new RotationalStiffness(poundforcefeetperdegrees, RotationalStiffnessUnit.PoundForceFootPerDegrees);
         }
 
         /// <summary>
@@ -817,9 +784,9 @@ public static RotationalStiffness FromPoundForceFeetPerDegrees(QuantityValue pou
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RotationalStiffness unit value.</returns>
-        public static RotationalStiffness From(QuantityValue value, RotationalStiffnessUnit fromUnit)
+        public static RotationalStiffness From(double value, RotationalStiffnessUnit fromUnit)
         {
-            return new RotationalStiffness((double)value, fromUnit);
+            return new RotationalStiffness(value, fromUnit);
         }
 
         #endregion
@@ -1252,15 +1219,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RotationalStiffnessUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RotationalStiffnessUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessUnit)} is supported.", nameof(unit));
@@ -1439,18 +1397,6 @@ public RotationalStiffness ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RotationalStiffnessUnit> IQuantity<RotationalStiffnessUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RotationalStiffnessUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
index 8c914284af..0610388521 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct RotationalStiffnessPerLength :
-        IArithmeticQuantity<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit, double>,
+        IArithmeticQuantity<RotationalStiffnessPerLength, RotationalStiffnessPerLengthUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<RotationalStiffnessPerLength, Length, RotationalStiffness>,
 #endif
@@ -157,7 +157,7 @@ public RotationalStiffnessPerLength(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -259,50 +259,45 @@ public static string GetAbbreviation(RotationalStiffnessPerLengthUnit unit, IFor
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter(QuantityValue kilonewtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter(double kilonewtonmetersperradianpermeter)
         {
-            double value = (double) kilonewtonmetersperradianpermeter;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength(kilonewtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFeet(QuantityValue kilopoundforcefeetperdegreesperfeet)
+        public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFeet(double kilopoundforcefeetperdegreesperfeet)
         {
-            double value = (double) kilopoundforcefeetperdegreesperfeet;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
+            return new RotationalStiffnessPerLength(kilopoundforcefeetperdegreesperfeet, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter(QuantityValue meganewtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter(double meganewtonmetersperradianpermeter)
         {
-            double value = (double) meganewtonmetersperradianpermeter;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength(meganewtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(QuantityValue newtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(double newtonmetersperradianpermeter)
         {
-            double value = (double) newtonmetersperradianpermeter;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength(newtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(QuantityValue poundforcefeetperdegreesperfeet)
+        public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(double poundforcefeetperdegreesperfeet)
         {
-            double value = (double) poundforcefeetperdegreesperfeet;
-            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
+            return new RotationalStiffnessPerLength(poundforcefeetperdegreesperfeet, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
         }
 
         /// <summary>
@@ -311,9 +306,9 @@ public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(Q
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>RotationalStiffnessPerLength unit value.</returns>
-        public static RotationalStiffnessPerLength From(QuantityValue value, RotationalStiffnessPerLengthUnit fromUnit)
+        public static RotationalStiffnessPerLength From(double value, RotationalStiffnessPerLengthUnit fromUnit)
         {
-            return new RotationalStiffnessPerLength((double)value, fromUnit);
+            return new RotationalStiffnessPerLength(value, fromUnit);
         }
 
         #endregion
@@ -734,15 +729,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is RotationalStiffnessPerLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessPerLengthUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is RotationalStiffnessPerLengthUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessPerLengthUnit)} is supported.", nameof(unit));
@@ -865,18 +851,6 @@ public RotationalStiffnessPerLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<RotationalStiffnessPerLengthUnit> IQuantity<RotationalStiffnessPerLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not RotationalStiffnessPerLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(RotationalStiffnessPerLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
index 7e354aaac0..0851f5db17 100644
--- a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Scalar :
-        IArithmeticQuantity<Scalar, ScalarUnit, double>,
+        IArithmeticQuantity<Scalar, ScalarUnit>,
         IComparable,
         IComparable<Scalar>,
         IConvertible,
@@ -147,7 +147,7 @@ public Scalar(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -221,10 +221,9 @@ public static string GetAbbreviation(ScalarUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Scalar"/> from <see cref="ScalarUnit.Amount"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Scalar FromAmount(QuantityValue amount)
+        public static Scalar FromAmount(double amount)
         {
-            double value = (double) amount;
-            return new Scalar(value, ScalarUnit.Amount);
+            return new Scalar(amount, ScalarUnit.Amount);
         }
 
         /// <summary>
@@ -233,9 +232,9 @@ public static Scalar FromAmount(QuantityValue amount)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Scalar unit value.</returns>
-        public static Scalar From(QuantityValue value, ScalarUnit fromUnit)
+        public static Scalar From(double value, ScalarUnit fromUnit)
         {
-            return new Scalar((double)value, fromUnit);
+            return new Scalar(value, fromUnit);
         }
 
         #endregion
@@ -646,15 +645,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ScalarUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ScalarUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ScalarUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ScalarUnit)} is supported.", nameof(unit));
@@ -769,18 +759,6 @@ public Scalar ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ScalarUnit> IQuantity<ScalarUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ScalarUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ScalarUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
index d6087d18e6..d53fbdc6b3 100644
--- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct SolidAngle :
-        IArithmeticQuantity<SolidAngle, SolidAngleUnit, double>,
+        IArithmeticQuantity<SolidAngle, SolidAngleUnit>,
         IComparable,
         IComparable<SolidAngle>,
         IConvertible,
@@ -150,7 +150,7 @@ public SolidAngle(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(SolidAngleUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="SolidAngle"/> from <see cref="SolidAngleUnit.Steradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SolidAngle FromSteradians(QuantityValue steradians)
+        public static SolidAngle FromSteradians(double steradians)
         {
-            double value = (double) steradians;
-            return new SolidAngle(value, SolidAngleUnit.Steradian);
+            return new SolidAngle(steradians, SolidAngleUnit.Steradian);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static SolidAngle FromSteradians(QuantityValue steradians)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SolidAngle unit value.</returns>
-        public static SolidAngle From(QuantityValue value, SolidAngleUnit fromUnit)
+        public static SolidAngle From(double value, SolidAngleUnit fromUnit)
         {
-            return new SolidAngle((double)value, fromUnit);
+            return new SolidAngle(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is SolidAngleUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SolidAngleUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is SolidAngleUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SolidAngleUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public SolidAngle ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SolidAngleUnit> IQuantity<SolidAngleUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not SolidAngleUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SolidAngleUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
index c757fb0091..2ef4ebbb14 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct SpecificEnergy :
-        IArithmeticQuantity<SpecificEnergy, SpecificEnergyUnit, double>,
+        IArithmeticQuantity<SpecificEnergy, SpecificEnergyUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<SpecificEnergy, Mass, Energy>,
         IMultiplyOperators<SpecificEnergy, MassFlow, Power>,
@@ -188,7 +188,7 @@ public SpecificEnergy(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -465,300 +465,270 @@ public static string GetAbbreviation(SpecificEnergyUnit unit, IFormatProvider? p
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.BtuPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromBtuPerPound(QuantityValue btuperpound)
+        public static SpecificEnergy FromBtuPerPound(double btuperpound)
         {
-            double value = (double) btuperpound;
-            return new SpecificEnergy(value, SpecificEnergyUnit.BtuPerPound);
+            return new SpecificEnergy(btuperpound, SpecificEnergyUnit.BtuPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.CaloriePerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromCaloriesPerGram(QuantityValue caloriespergram)
+        public static SpecificEnergy FromCaloriesPerGram(double caloriespergram)
         {
-            double value = (double) caloriespergram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.CaloriePerGram);
+            return new SpecificEnergy(caloriespergram, SpecificEnergyUnit.CaloriePerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerKilogram(QuantityValue gigawattdaysperkilogram)
+        public static SpecificEnergy FromGigawattDaysPerKilogram(double gigawattdaysperkilogram)
         {
-            double value = (double) gigawattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerKilogram);
+            return new SpecificEnergy(gigawattdaysperkilogram, SpecificEnergyUnit.GigawattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerShortTon(QuantityValue gigawattdayspershortton)
+        public static SpecificEnergy FromGigawattDaysPerShortTon(double gigawattdayspershortton)
         {
-            double value = (double) gigawattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerShortTon);
+            return new SpecificEnergy(gigawattdayspershortton, SpecificEnergyUnit.GigawattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerTonne(QuantityValue gigawattdayspertonne)
+        public static SpecificEnergy FromGigawattDaysPerTonne(double gigawattdayspertonne)
         {
-            double value = (double) gigawattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerTonne);
+            return new SpecificEnergy(gigawattdayspertonne, SpecificEnergyUnit.GigawattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattHourPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattHoursPerKilogram(QuantityValue gigawatthoursperkilogram)
+        public static SpecificEnergy FromGigawattHoursPerKilogram(double gigawatthoursperkilogram)
         {
-            double value = (double) gigawatthoursperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerKilogram);
+            return new SpecificEnergy(gigawatthoursperkilogram, SpecificEnergyUnit.GigawattHourPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattHourPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattHoursPerPound(QuantityValue gigawatthoursperpound)
+        public static SpecificEnergy FromGigawattHoursPerPound(double gigawatthoursperpound)
         {
-            double value = (double) gigawatthoursperpound;
-            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerPound);
+            return new SpecificEnergy(gigawatthoursperpound, SpecificEnergyUnit.GigawattHourPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.JoulePerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromJoulesPerKilogram(QuantityValue joulesperkilogram)
+        public static SpecificEnergy FromJoulesPerKilogram(double joulesperkilogram)
         {
-            double value = (double) joulesperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.JoulePerKilogram);
+            return new SpecificEnergy(joulesperkilogram, SpecificEnergyUnit.JoulePerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilocaloriePerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilocaloriesPerGram(QuantityValue kilocaloriespergram)
+        public static SpecificEnergy FromKilocaloriesPerGram(double kilocaloriespergram)
         {
-            double value = (double) kilocaloriespergram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilocaloriePerGram);
+            return new SpecificEnergy(kilocaloriespergram, SpecificEnergyUnit.KilocaloriePerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilojoulePerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilojoulesPerKilogram(QuantityValue kilojoulesperkilogram)
+        public static SpecificEnergy FromKilojoulesPerKilogram(double kilojoulesperkilogram)
         {
-            double value = (double) kilojoulesperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilojoulePerKilogram);
+            return new SpecificEnergy(kilojoulesperkilogram, SpecificEnergyUnit.KilojoulePerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerKilogram(QuantityValue kilowattdaysperkilogram)
+        public static SpecificEnergy FromKilowattDaysPerKilogram(double kilowattdaysperkilogram)
         {
-            double value = (double) kilowattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerKilogram);
+            return new SpecificEnergy(kilowattdaysperkilogram, SpecificEnergyUnit.KilowattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerShortTon(QuantityValue kilowattdayspershortton)
+        public static SpecificEnergy FromKilowattDaysPerShortTon(double kilowattdayspershortton)
         {
-            double value = (double) kilowattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerShortTon);
+            return new SpecificEnergy(kilowattdayspershortton, SpecificEnergyUnit.KilowattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerTonne(QuantityValue kilowattdayspertonne)
+        public static SpecificEnergy FromKilowattDaysPerTonne(double kilowattdayspertonne)
         {
-            double value = (double) kilowattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerTonne);
+            return new SpecificEnergy(kilowattdayspertonne, SpecificEnergyUnit.KilowattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattHourPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattHoursPerKilogram(QuantityValue kilowatthoursperkilogram)
+        public static SpecificEnergy FromKilowattHoursPerKilogram(double kilowatthoursperkilogram)
         {
-            double value = (double) kilowatthoursperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerKilogram);
+            return new SpecificEnergy(kilowatthoursperkilogram, SpecificEnergyUnit.KilowattHourPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattHourPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattHoursPerPound(QuantityValue kilowatthoursperpound)
+        public static SpecificEnergy FromKilowattHoursPerPound(double kilowatthoursperpound)
         {
-            double value = (double) kilowatthoursperpound;
-            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerPound);
+            return new SpecificEnergy(kilowatthoursperpound, SpecificEnergyUnit.KilowattHourPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegajoulePerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegajoulesPerKilogram(QuantityValue megajoulesperkilogram)
+        public static SpecificEnergy FromMegajoulesPerKilogram(double megajoulesperkilogram)
         {
-            double value = (double) megajoulesperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerKilogram);
+            return new SpecificEnergy(megajoulesperkilogram, SpecificEnergyUnit.MegajoulePerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegaJoulePerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegaJoulesPerTonne(QuantityValue megajoulespertonne)
+        public static SpecificEnergy FromMegaJoulesPerTonne(double megajoulespertonne)
         {
-            double value = (double) megajoulespertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegaJoulePerTonne);
+            return new SpecificEnergy(megajoulespertonne, SpecificEnergyUnit.MegaJoulePerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerKilogram(QuantityValue megawattdaysperkilogram)
+        public static SpecificEnergy FromMegawattDaysPerKilogram(double megawattdaysperkilogram)
         {
-            double value = (double) megawattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerKilogram);
+            return new SpecificEnergy(megawattdaysperkilogram, SpecificEnergyUnit.MegawattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerShortTon(QuantityValue megawattdayspershortton)
+        public static SpecificEnergy FromMegawattDaysPerShortTon(double megawattdayspershortton)
         {
-            double value = (double) megawattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerShortTon);
+            return new SpecificEnergy(megawattdayspershortton, SpecificEnergyUnit.MegawattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerTonne(QuantityValue megawattdayspertonne)
+        public static SpecificEnergy FromMegawattDaysPerTonne(double megawattdayspertonne)
         {
-            double value = (double) megawattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerTonne);
+            return new SpecificEnergy(megawattdayspertonne, SpecificEnergyUnit.MegawattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattHourPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattHoursPerKilogram(QuantityValue megawatthoursperkilogram)
+        public static SpecificEnergy FromMegawattHoursPerKilogram(double megawatthoursperkilogram)
         {
-            double value = (double) megawatthoursperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerKilogram);
+            return new SpecificEnergy(megawatthoursperkilogram, SpecificEnergyUnit.MegawattHourPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattHourPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattHoursPerPound(QuantityValue megawatthoursperpound)
+        public static SpecificEnergy FromMegawattHoursPerPound(double megawatthoursperpound)
         {
-            double value = (double) megawatthoursperpound;
-            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerPound);
+            return new SpecificEnergy(megawatthoursperpound, SpecificEnergyUnit.MegawattHourPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerKilogram(QuantityValue terawattdaysperkilogram)
+        public static SpecificEnergy FromTerawattDaysPerKilogram(double terawattdaysperkilogram)
         {
-            double value = (double) terawattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerKilogram);
+            return new SpecificEnergy(terawattdaysperkilogram, SpecificEnergyUnit.TerawattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerShortTon(QuantityValue terawattdayspershortton)
+        public static SpecificEnergy FromTerawattDaysPerShortTon(double terawattdayspershortton)
         {
-            double value = (double) terawattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerShortTon);
+            return new SpecificEnergy(terawattdayspershortton, SpecificEnergyUnit.TerawattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerTonne(QuantityValue terawattdayspertonne)
+        public static SpecificEnergy FromTerawattDaysPerTonne(double terawattdayspertonne)
         {
-            double value = (double) terawattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerTonne);
+            return new SpecificEnergy(terawattdayspertonne, SpecificEnergyUnit.TerawattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerKilogram(QuantityValue wattdaysperkilogram)
+        public static SpecificEnergy FromWattDaysPerKilogram(double wattdaysperkilogram)
         {
-            double value = (double) wattdaysperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerKilogram);
+            return new SpecificEnergy(wattdaysperkilogram, SpecificEnergyUnit.WattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerShortTon(QuantityValue wattdayspershortton)
+        public static SpecificEnergy FromWattDaysPerShortTon(double wattdayspershortton)
         {
-            double value = (double) wattdayspershortton;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerShortTon);
+            return new SpecificEnergy(wattdayspershortton, SpecificEnergyUnit.WattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerTonne(QuantityValue wattdayspertonne)
+        public static SpecificEnergy FromWattDaysPerTonne(double wattdayspertonne)
         {
-            double value = (double) wattdayspertonne;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerTonne);
+            return new SpecificEnergy(wattdayspertonne, SpecificEnergyUnit.WattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattHourPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattHoursPerKilogram(QuantityValue watthoursperkilogram)
+        public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogram)
         {
-            double value = (double) watthoursperkilogram;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerKilogram);
+            return new SpecificEnergy(watthoursperkilogram, SpecificEnergyUnit.WattHourPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattHourPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattHoursPerPound(QuantityValue watthoursperpound)
+        public static SpecificEnergy FromWattHoursPerPound(double watthoursperpound)
         {
-            double value = (double) watthoursperpound;
-            return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerPound);
+            return new SpecificEnergy(watthoursperpound, SpecificEnergyUnit.WattHourPerPound);
         }
 
         /// <summary>
@@ -767,9 +737,9 @@ public static SpecificEnergy FromWattHoursPerPound(QuantityValue watthoursperpou
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificEnergy unit value.</returns>
-        public static SpecificEnergy From(QuantityValue value, SpecificEnergyUnit fromUnit)
+        public static SpecificEnergy From(double value, SpecificEnergyUnit fromUnit)
         {
-            return new SpecificEnergy((double)value, fromUnit);
+            return new SpecificEnergy(value, fromUnit);
         }
 
         #endregion
@@ -1214,15 +1184,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is SpecificEnergyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEnergyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is SpecificEnergyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEnergyUnit)} is supported.", nameof(unit));
@@ -1395,18 +1356,6 @@ public SpecificEnergy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificEnergyUnit> IQuantity<SpecificEnergyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not SpecificEnergyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEnergyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
index 308a10e0f5..7111f179f8 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct SpecificEntropy :
-        IArithmeticQuantity<SpecificEntropy, SpecificEntropyUnit, double>,
+        IArithmeticQuantity<SpecificEntropy, SpecificEntropyUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<SpecificEntropy, Mass, Entropy>,
         IMultiplyOperators<SpecificEntropy, TemperatureDelta, SpecificEnergy>,
@@ -162,7 +162,7 @@ public SpecificEntropy(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -292,90 +292,81 @@ public static string GetAbbreviation(SpecificEntropyUnit unit, IFormatProvider?
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.BtuPerPoundFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromBtusPerPoundFahrenheit(QuantityValue btusperpoundfahrenheit)
+        public static SpecificEntropy FromBtusPerPoundFahrenheit(double btusperpoundfahrenheit)
         {
-            double value = (double) btusperpoundfahrenheit;
-            return new SpecificEntropy(value, SpecificEntropyUnit.BtuPerPoundFahrenheit);
+            return new SpecificEntropy(btusperpoundfahrenheit, SpecificEntropyUnit.BtuPerPoundFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.CaloriePerGramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromCaloriesPerGramKelvin(QuantityValue caloriespergramkelvin)
+        public static SpecificEntropy FromCaloriesPerGramKelvin(double caloriespergramkelvin)
         {
-            double value = (double) caloriespergramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.CaloriePerGramKelvin);
+            return new SpecificEntropy(caloriespergramkelvin, SpecificEntropyUnit.CaloriePerGramKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.JoulePerKilogramDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(QuantityValue joulesperkilogramdegreecelsius)
+        public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(double joulesperkilogramdegreecelsius)
         {
-            double value = (double) joulesperkilogramdegreecelsius;
-            return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy(joulesperkilogramdegreecelsius, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.JoulePerKilogramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromJoulesPerKilogramKelvin(QuantityValue joulesperkilogramkelvin)
+        public static SpecificEntropy FromJoulesPerKilogramKelvin(double joulesperkilogramkelvin)
         {
-            double value = (double) joulesperkilogramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramKelvin);
+            return new SpecificEntropy(joulesperkilogramkelvin, SpecificEntropyUnit.JoulePerKilogramKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilocaloriePerGramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilocaloriesPerGramKelvin(QuantityValue kilocaloriespergramkelvin)
+        public static SpecificEntropy FromKilocaloriesPerGramKelvin(double kilocaloriespergramkelvin)
         {
-            double value = (double) kilocaloriespergramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.KilocaloriePerGramKelvin);
+            return new SpecificEntropy(kilocaloriespergramkelvin, SpecificEntropyUnit.KilocaloriePerGramKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(QuantityValue kilojoulesperkilogramdegreecelsius)
+        public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(double kilojoulesperkilogramdegreecelsius)
         {
-            double value = (double) kilojoulesperkilogramdegreecelsius;
-            return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy(kilojoulesperkilogramdegreecelsius, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilojoulePerKilogramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilojoulesPerKilogramKelvin(QuantityValue kilojoulesperkilogramkelvin)
+        public static SpecificEntropy FromKilojoulesPerKilogramKelvin(double kilojoulesperkilogramkelvin)
         {
-            double value = (double) kilojoulesperkilogramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
+            return new SpecificEntropy(kilojoulesperkilogramkelvin, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(QuantityValue megajoulesperkilogramdegreecelsius)
+        public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(double megajoulesperkilogramdegreecelsius)
         {
-            double value = (double) megajoulesperkilogramdegreecelsius;
-            return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy(megajoulesperkilogramdegreecelsius, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.MegajoulePerKilogramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromMegajoulesPerKilogramKelvin(QuantityValue megajoulesperkilogramkelvin)
+        public static SpecificEntropy FromMegajoulesPerKilogramKelvin(double megajoulesperkilogramkelvin)
         {
-            double value = (double) megajoulesperkilogramkelvin;
-            return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
+            return new SpecificEntropy(megajoulesperkilogramkelvin, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
         }
 
         /// <summary>
@@ -384,9 +375,9 @@ public static SpecificEntropy FromMegajoulesPerKilogramKelvin(QuantityValue mega
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificEntropy unit value.</returns>
-        public static SpecificEntropy From(QuantityValue value, SpecificEntropyUnit fromUnit)
+        public static SpecificEntropy From(double value, SpecificEntropyUnit fromUnit)
         {
-            return new SpecificEntropy((double)value, fromUnit);
+            return new SpecificEntropy(value, fromUnit);
         }
 
         #endregion
@@ -813,15 +804,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is SpecificEntropyUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEntropyUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is SpecificEntropyUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEntropyUnit)} is supported.", nameof(unit));
@@ -952,18 +934,6 @@ public SpecificEntropy ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificEntropyUnit> IQuantity<SpecificEntropyUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not SpecificEntropyUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificEntropyUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
index c292ceeef9..f98426d202 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct SpecificFuelConsumption :
-        IArithmeticQuantity<SpecificFuelConsumption, SpecificFuelConsumptionUnit, double>,
+        IArithmeticQuantity<SpecificFuelConsumption, SpecificFuelConsumptionUnit>,
         IComparable,
         IComparable<SpecificFuelConsumption>,
         IConvertible,
@@ -153,7 +153,7 @@ public SpecificFuelConsumption(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -248,40 +248,36 @@ public static string GetAbbreviation(SpecificFuelConsumptionUnit unit, IFormatPr
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificFuelConsumption FromGramsPerKiloNewtonSecond(QuantityValue gramsperkilonewtonsecond)
+        public static SpecificFuelConsumption FromGramsPerKiloNewtonSecond(double gramsperkilonewtonsecond)
         {
-            double value = (double) gramsperkilonewtonsecond;
-            return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond);
+            return new SpecificFuelConsumption(gramsperkilonewtonsecond, SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(QuantityValue kilogramsperkilogramforcehour)
+        public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(double kilogramsperkilogramforcehour)
         {
-            double value = (double) kilogramsperkilogramforcehour;
-            return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
+            return new SpecificFuelConsumption(kilogramsperkilogramforcehour, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificFuelConsumption FromKilogramsPerKiloNewtonSecond(QuantityValue kilogramsperkilonewtonsecond)
+        public static SpecificFuelConsumption FromKilogramsPerKiloNewtonSecond(double kilogramsperkilonewtonsecond)
         {
-            double value = (double) kilogramsperkilonewtonsecond;
-            return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond);
+            return new SpecificFuelConsumption(kilogramsperkilonewtonsecond, SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(QuantityValue poundsmassperpoundforcehour)
+        public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(double poundsmassperpoundforcehour)
         {
-            double value = (double) poundsmassperpoundforcehour;
-            return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
+            return new SpecificFuelConsumption(poundsmassperpoundforcehour, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
         }
 
         /// <summary>
@@ -290,9 +286,9 @@ public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(QuantityVa
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificFuelConsumption unit value.</returns>
-        public static SpecificFuelConsumption From(QuantityValue value, SpecificFuelConsumptionUnit fromUnit)
+        public static SpecificFuelConsumption From(double value, SpecificFuelConsumptionUnit fromUnit)
         {
-            return new SpecificFuelConsumption((double)value, fromUnit);
+            return new SpecificFuelConsumption(value, fromUnit);
         }
 
         #endregion
@@ -703,15 +699,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is SpecificFuelConsumptionUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificFuelConsumptionUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is SpecificFuelConsumptionUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificFuelConsumptionUnit)} is supported.", nameof(unit));
@@ -832,18 +819,6 @@ public SpecificFuelConsumption ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificFuelConsumptionUnit> IQuantity<SpecificFuelConsumptionUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not SpecificFuelConsumptionUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificFuelConsumptionUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
index bf896f2a04..ec08b56d95 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct SpecificVolume :
-        IArithmeticQuantity<SpecificVolume, SpecificVolumeUnit, double>,
+        IArithmeticQuantity<SpecificVolume, SpecificVolumeUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<SpecificVolume, Mass, Volume>,
 #endif
@@ -155,7 +155,7 @@ public SpecificVolume(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -243,30 +243,27 @@ public static string GetAbbreviation(SpecificVolumeUnit unit, IFormatProvider? p
         ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicFootPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromCubicFeetPerPound(QuantityValue cubicfeetperpound)
+        public static SpecificVolume FromCubicFeetPerPound(double cubicfeetperpound)
         {
-            double value = (double) cubicfeetperpound;
-            return new SpecificVolume(value, SpecificVolumeUnit.CubicFootPerPound);
+            return new SpecificVolume(cubicfeetperpound, SpecificVolumeUnit.CubicFootPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicMeterPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromCubicMetersPerKilogram(QuantityValue cubicmetersperkilogram)
+        public static SpecificVolume FromCubicMetersPerKilogram(double cubicmetersperkilogram)
         {
-            double value = (double) cubicmetersperkilogram;
-            return new SpecificVolume(value, SpecificVolumeUnit.CubicMeterPerKilogram);
+            return new SpecificVolume(cubicmetersperkilogram, SpecificVolumeUnit.CubicMeterPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.MillicubicMeterPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromMillicubicMetersPerKilogram(QuantityValue millicubicmetersperkilogram)
+        public static SpecificVolume FromMillicubicMetersPerKilogram(double millicubicmetersperkilogram)
         {
-            double value = (double) millicubicmetersperkilogram;
-            return new SpecificVolume(value, SpecificVolumeUnit.MillicubicMeterPerKilogram);
+            return new SpecificVolume(millicubicmetersperkilogram, SpecificVolumeUnit.MillicubicMeterPerKilogram);
         }
 
         /// <summary>
@@ -275,9 +272,9 @@ public static SpecificVolume FromMillicubicMetersPerKilogram(QuantityValue milli
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificVolume unit value.</returns>
-        public static SpecificVolume From(QuantityValue value, SpecificVolumeUnit fromUnit)
+        public static SpecificVolume From(double value, SpecificVolumeUnit fromUnit)
         {
-            return new SpecificVolume((double)value, fromUnit);
+            return new SpecificVolume(value, fromUnit);
         }
 
         #endregion
@@ -704,15 +701,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is SpecificVolumeUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificVolumeUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is SpecificVolumeUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificVolumeUnit)} is supported.", nameof(unit));
@@ -831,18 +819,6 @@ public SpecificVolume ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificVolumeUnit> IQuantity<SpecificVolumeUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not SpecificVolumeUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificVolumeUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
index c6141cac2a..1c863125ad 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct SpecificWeight :
-        IArithmeticQuantity<SpecificWeight, SpecificWeightUnit, double>,
+        IArithmeticQuantity<SpecificWeight, SpecificWeightUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<SpecificWeight, Density, Acceleration>,
         IDivisionOperators<SpecificWeight, Acceleration, Density>,
@@ -175,7 +175,7 @@ public SpecificWeight(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -361,170 +361,153 @@ public static string GetAbbreviation(SpecificWeightUnit unit, IFormatProvider? p
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicCentimeter(QuantityValue kilogramsforcepercubiccentimeter)
+        public static SpecificWeight FromKilogramsForcePerCubicCentimeter(double kilogramsforcepercubiccentimeter)
         {
-            double value = (double) kilogramsforcepercubiccentimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
+            return new SpecificWeight(kilogramsforcepercubiccentimeter, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicMeter(QuantityValue kilogramsforcepercubicmeter)
+        public static SpecificWeight FromKilogramsForcePerCubicMeter(double kilogramsforcepercubicmeter)
         {
-            double value = (double) kilogramsforcepercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMeter);
+            return new SpecificWeight(kilogramsforcepercubicmeter, SpecificWeightUnit.KilogramForcePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicMillimeter(QuantityValue kilogramsforcepercubicmillimeter)
+        public static SpecificWeight FromKilogramsForcePerCubicMillimeter(double kilogramsforcepercubicmillimeter)
         {
-            double value = (double) kilogramsforcepercubicmillimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
+            return new SpecificWeight(kilogramsforcepercubicmillimeter, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicCentimeter(QuantityValue kilonewtonspercubiccentimeter)
+        public static SpecificWeight FromKilonewtonsPerCubicCentimeter(double kilonewtonspercubiccentimeter)
         {
-            double value = (double) kilonewtonspercubiccentimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
+            return new SpecificWeight(kilonewtonspercubiccentimeter, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicMeter(QuantityValue kilonewtonspercubicmeter)
+        public static SpecificWeight FromKilonewtonsPerCubicMeter(double kilonewtonspercubicmeter)
         {
-            double value = (double) kilonewtonspercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMeter);
+            return new SpecificWeight(kilonewtonspercubicmeter, SpecificWeightUnit.KilonewtonPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicMillimeter(QuantityValue kilonewtonspercubicmillimeter)
+        public static SpecificWeight FromKilonewtonsPerCubicMillimeter(double kilonewtonspercubicmillimeter)
         {
-            double value = (double) kilonewtonspercubicmillimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
+            return new SpecificWeight(kilonewtonspercubicmillimeter, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilopoundForcePerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilopoundsForcePerCubicFoot(QuantityValue kilopoundsforcepercubicfoot)
+        public static SpecificWeight FromKilopoundsForcePerCubicFoot(double kilopoundsforcepercubicfoot)
         {
-            double value = (double) kilopoundsforcepercubicfoot;
-            return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicFoot);
+            return new SpecificWeight(kilopoundsforcepercubicfoot, SpecificWeightUnit.KilopoundForcePerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilopoundForcePerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilopoundsForcePerCubicInch(QuantityValue kilopoundsforcepercubicinch)
+        public static SpecificWeight FromKilopoundsForcePerCubicInch(double kilopoundsforcepercubicinch)
         {
-            double value = (double) kilopoundsforcepercubicinch;
-            return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicInch);
+            return new SpecificWeight(kilopoundsforcepercubicinch, SpecificWeightUnit.KilopoundForcePerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.MeganewtonPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromMeganewtonsPerCubicMeter(QuantityValue meganewtonspercubicmeter)
+        public static SpecificWeight FromMeganewtonsPerCubicMeter(double meganewtonspercubicmeter)
         {
-            double value = (double) meganewtonspercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.MeganewtonPerCubicMeter);
+            return new SpecificWeight(meganewtonspercubicmeter, SpecificWeightUnit.MeganewtonPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicCentimeter(QuantityValue newtonspercubiccentimeter)
+        public static SpecificWeight FromNewtonsPerCubicCentimeter(double newtonspercubiccentimeter)
         {
-            double value = (double) newtonspercubiccentimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicCentimeter);
+            return new SpecificWeight(newtonspercubiccentimeter, SpecificWeightUnit.NewtonPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicMeter(QuantityValue newtonspercubicmeter)
+        public static SpecificWeight FromNewtonsPerCubicMeter(double newtonspercubicmeter)
         {
-            double value = (double) newtonspercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMeter);
+            return new SpecificWeight(newtonspercubicmeter, SpecificWeightUnit.NewtonPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicMillimeter(QuantityValue newtonspercubicmillimeter)
+        public static SpecificWeight FromNewtonsPerCubicMillimeter(double newtonspercubicmillimeter)
         {
-            double value = (double) newtonspercubicmillimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMillimeter);
+            return new SpecificWeight(newtonspercubicmillimeter, SpecificWeightUnit.NewtonPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.PoundForcePerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromPoundsForcePerCubicFoot(QuantityValue poundsforcepercubicfoot)
+        public static SpecificWeight FromPoundsForcePerCubicFoot(double poundsforcepercubicfoot)
         {
-            double value = (double) poundsforcepercubicfoot;
-            return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicFoot);
+            return new SpecificWeight(poundsforcepercubicfoot, SpecificWeightUnit.PoundForcePerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.PoundForcePerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromPoundsForcePerCubicInch(QuantityValue poundsforcepercubicinch)
+        public static SpecificWeight FromPoundsForcePerCubicInch(double poundsforcepercubicinch)
         {
-            double value = (double) poundsforcepercubicinch;
-            return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicInch);
+            return new SpecificWeight(poundsforcepercubicinch, SpecificWeightUnit.PoundForcePerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicCentimeter(QuantityValue tonnesforcepercubiccentimeter)
+        public static SpecificWeight FromTonnesForcePerCubicCentimeter(double tonnesforcepercubiccentimeter)
         {
-            double value = (double) tonnesforcepercubiccentimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicCentimeter);
+            return new SpecificWeight(tonnesforcepercubiccentimeter, SpecificWeightUnit.TonneForcePerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicMeter(QuantityValue tonnesforcepercubicmeter)
+        public static SpecificWeight FromTonnesForcePerCubicMeter(double tonnesforcepercubicmeter)
         {
-            double value = (double) tonnesforcepercubicmeter;
-            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMeter);
+            return new SpecificWeight(tonnesforcepercubicmeter, SpecificWeightUnit.TonneForcePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicMillimeter(QuantityValue tonnesforcepercubicmillimeter)
+        public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforcepercubicmillimeter)
         {
-            double value = (double) tonnesforcepercubicmillimeter;
-            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMillimeter);
+            return new SpecificWeight(tonnesforcepercubicmillimeter, SpecificWeightUnit.TonneForcePerCubicMillimeter);
         }
 
         /// <summary>
@@ -533,9 +516,9 @@ public static SpecificWeight FromTonnesForcePerCubicMillimeter(QuantityValue ton
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>SpecificWeight unit value.</returns>
-        public static SpecificWeight From(QuantityValue value, SpecificWeightUnit fromUnit)
+        public static SpecificWeight From(double value, SpecificWeightUnit fromUnit)
         {
-            return new SpecificWeight((double)value, fromUnit);
+            return new SpecificWeight(value, fromUnit);
         }
 
         #endregion
@@ -974,15 +957,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is SpecificWeightUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificWeightUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is SpecificWeightUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificWeightUnit)} is supported.", nameof(unit));
@@ -1129,18 +1103,6 @@ public SpecificWeight ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpecificWeightUnit> IQuantity<SpecificWeightUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not SpecificWeightUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpecificWeightUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
index 06ade9b4bb..8bf4d96a66 100644
--- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Speed :
-        IArithmeticQuantity<Speed, SpeedUnit, double>,
+        IArithmeticQuantity<Speed, SpeedUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Speed, Duration, Acceleration>,
         IDivisionOperators<Speed, TimeSpan, Acceleration>,
@@ -194,7 +194,7 @@ public Speed(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -492,330 +492,297 @@ public static string GetAbbreviation(SpeedUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerHour(QuantityValue centimetersperhour)
+        public static Speed FromCentimetersPerHour(double centimetersperhour)
         {
-            double value = (double) centimetersperhour;
-            return new Speed(value, SpeedUnit.CentimeterPerHour);
+            return new Speed(centimetersperhour, SpeedUnit.CentimeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerMinute(QuantityValue centimetersperminute)
+        public static Speed FromCentimetersPerMinute(double centimetersperminute)
         {
-            double value = (double) centimetersperminute;
-            return new Speed(value, SpeedUnit.CentimeterPerMinute);
+            return new Speed(centimetersperminute, SpeedUnit.CentimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerSecond(QuantityValue centimeterspersecond)
+        public static Speed FromCentimetersPerSecond(double centimeterspersecond)
         {
-            double value = (double) centimeterspersecond;
-            return new Speed(value, SpeedUnit.CentimeterPerSecond);
+            return new Speed(centimeterspersecond, SpeedUnit.CentimeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.DecimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromDecimetersPerMinute(QuantityValue decimetersperminute)
+        public static Speed FromDecimetersPerMinute(double decimetersperminute)
         {
-            double value = (double) decimetersperminute;
-            return new Speed(value, SpeedUnit.DecimeterPerMinute);
+            return new Speed(decimetersperminute, SpeedUnit.DecimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.DecimeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromDecimetersPerSecond(QuantityValue decimeterspersecond)
+        public static Speed FromDecimetersPerSecond(double decimeterspersecond)
         {
-            double value = (double) decimeterspersecond;
-            return new Speed(value, SpeedUnit.DecimeterPerSecond);
+            return new Speed(decimeterspersecond, SpeedUnit.DecimeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerHour(QuantityValue feetperhour)
+        public static Speed FromFeetPerHour(double feetperhour)
         {
-            double value = (double) feetperhour;
-            return new Speed(value, SpeedUnit.FootPerHour);
+            return new Speed(feetperhour, SpeedUnit.FootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerMinute(QuantityValue feetperminute)
+        public static Speed FromFeetPerMinute(double feetperminute)
         {
-            double value = (double) feetperminute;
-            return new Speed(value, SpeedUnit.FootPerMinute);
+            return new Speed(feetperminute, SpeedUnit.FootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerSecond(QuantityValue feetpersecond)
+        public static Speed FromFeetPerSecond(double feetpersecond)
         {
-            double value = (double) feetpersecond;
-            return new Speed(value, SpeedUnit.FootPerSecond);
+            return new Speed(feetpersecond, SpeedUnit.FootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerHour(QuantityValue inchesperhour)
+        public static Speed FromInchesPerHour(double inchesperhour)
         {
-            double value = (double) inchesperhour;
-            return new Speed(value, SpeedUnit.InchPerHour);
+            return new Speed(inchesperhour, SpeedUnit.InchPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerMinute(QuantityValue inchesperminute)
+        public static Speed FromInchesPerMinute(double inchesperminute)
         {
-            double value = (double) inchesperminute;
-            return new Speed(value, SpeedUnit.InchPerMinute);
+            return new Speed(inchesperminute, SpeedUnit.InchPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerSecond(QuantityValue inchespersecond)
+        public static Speed FromInchesPerSecond(double inchespersecond)
         {
-            double value = (double) inchespersecond;
-            return new Speed(value, SpeedUnit.InchPerSecond);
+            return new Speed(inchespersecond, SpeedUnit.InchPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerHour(QuantityValue kilometersperhour)
+        public static Speed FromKilometersPerHour(double kilometersperhour)
         {
-            double value = (double) kilometersperhour;
-            return new Speed(value, SpeedUnit.KilometerPerHour);
+            return new Speed(kilometersperhour, SpeedUnit.KilometerPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerMinute(QuantityValue kilometersperminute)
+        public static Speed FromKilometersPerMinute(double kilometersperminute)
         {
-            double value = (double) kilometersperminute;
-            return new Speed(value, SpeedUnit.KilometerPerMinute);
+            return new Speed(kilometersperminute, SpeedUnit.KilometerPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerSecond(QuantityValue kilometerspersecond)
+        public static Speed FromKilometersPerSecond(double kilometerspersecond)
         {
-            double value = (double) kilometerspersecond;
-            return new Speed(value, SpeedUnit.KilometerPerSecond);
+            return new Speed(kilometerspersecond, SpeedUnit.KilometerPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.Knot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKnots(QuantityValue knots)
+        public static Speed FromKnots(double knots)
         {
-            double value = (double) knots;
-            return new Speed(value, SpeedUnit.Knot);
+            return new Speed(knots, SpeedUnit.Knot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.Mach"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMach(QuantityValue mach)
+        public static Speed FromMach(double mach)
         {
-            double value = (double) mach;
-            return new Speed(value, SpeedUnit.Mach);
+            return new Speed(mach, SpeedUnit.Mach);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerHour(QuantityValue metersperhour)
+        public static Speed FromMetersPerHour(double metersperhour)
         {
-            double value = (double) metersperhour;
-            return new Speed(value, SpeedUnit.MeterPerHour);
+            return new Speed(metersperhour, SpeedUnit.MeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerMinute(QuantityValue metersperminute)
+        public static Speed FromMetersPerMinute(double metersperminute)
         {
-            double value = (double) metersperminute;
-            return new Speed(value, SpeedUnit.MeterPerMinute);
+            return new Speed(metersperminute, SpeedUnit.MeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerSecond(QuantityValue meterspersecond)
+        public static Speed FromMetersPerSecond(double meterspersecond)
         {
-            double value = (double) meterspersecond;
-            return new Speed(value, SpeedUnit.MeterPerSecond);
+            return new Speed(meterspersecond, SpeedUnit.MeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MicrometerPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMicrometersPerMinute(QuantityValue micrometersperminute)
+        public static Speed FromMicrometersPerMinute(double micrometersperminute)
         {
-            double value = (double) micrometersperminute;
-            return new Speed(value, SpeedUnit.MicrometerPerMinute);
+            return new Speed(micrometersperminute, SpeedUnit.MicrometerPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MicrometerPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMicrometersPerSecond(QuantityValue micrometerspersecond)
+        public static Speed FromMicrometersPerSecond(double micrometerspersecond)
         {
-            double value = (double) micrometerspersecond;
-            return new Speed(value, SpeedUnit.MicrometerPerSecond);
+            return new Speed(micrometerspersecond, SpeedUnit.MicrometerPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MilePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMilesPerHour(QuantityValue milesperhour)
+        public static Speed FromMilesPerHour(double milesperhour)
         {
-            double value = (double) milesperhour;
-            return new Speed(value, SpeedUnit.MilePerHour);
+            return new Speed(milesperhour, SpeedUnit.MilePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerHour(QuantityValue millimetersperhour)
+        public static Speed FromMillimetersPerHour(double millimetersperhour)
         {
-            double value = (double) millimetersperhour;
-            return new Speed(value, SpeedUnit.MillimeterPerHour);
+            return new Speed(millimetersperhour, SpeedUnit.MillimeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerMinute(QuantityValue millimetersperminute)
+        public static Speed FromMillimetersPerMinute(double millimetersperminute)
         {
-            double value = (double) millimetersperminute;
-            return new Speed(value, SpeedUnit.MillimeterPerMinute);
+            return new Speed(millimetersperminute, SpeedUnit.MillimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerSecond(QuantityValue millimeterspersecond)
+        public static Speed FromMillimetersPerSecond(double millimeterspersecond)
         {
-            double value = (double) millimeterspersecond;
-            return new Speed(value, SpeedUnit.MillimeterPerSecond);
+            return new Speed(millimeterspersecond, SpeedUnit.MillimeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.NanometerPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromNanometersPerMinute(QuantityValue nanometersperminute)
+        public static Speed FromNanometersPerMinute(double nanometersperminute)
         {
-            double value = (double) nanometersperminute;
-            return new Speed(value, SpeedUnit.NanometerPerMinute);
+            return new Speed(nanometersperminute, SpeedUnit.NanometerPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.NanometerPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromNanometersPerSecond(QuantityValue nanometerspersecond)
+        public static Speed FromNanometersPerSecond(double nanometerspersecond)
         {
-            double value = (double) nanometerspersecond;
-            return new Speed(value, SpeedUnit.NanometerPerSecond);
+            return new Speed(nanometerspersecond, SpeedUnit.NanometerPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerHour(QuantityValue ussurveyfeetperhour)
+        public static Speed FromUsSurveyFeetPerHour(double ussurveyfeetperhour)
         {
-            double value = (double) ussurveyfeetperhour;
-            return new Speed(value, SpeedUnit.UsSurveyFootPerHour);
+            return new Speed(ussurveyfeetperhour, SpeedUnit.UsSurveyFootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerMinute(QuantityValue ussurveyfeetperminute)
+        public static Speed FromUsSurveyFeetPerMinute(double ussurveyfeetperminute)
         {
-            double value = (double) ussurveyfeetperminute;
-            return new Speed(value, SpeedUnit.UsSurveyFootPerMinute);
+            return new Speed(ussurveyfeetperminute, SpeedUnit.UsSurveyFootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerSecond(QuantityValue ussurveyfeetpersecond)
+        public static Speed FromUsSurveyFeetPerSecond(double ussurveyfeetpersecond)
         {
-            double value = (double) ussurveyfeetpersecond;
-            return new Speed(value, SpeedUnit.UsSurveyFootPerSecond);
+            return new Speed(ussurveyfeetpersecond, SpeedUnit.UsSurveyFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerHour(QuantityValue yardsperhour)
+        public static Speed FromYardsPerHour(double yardsperhour)
         {
-            double value = (double) yardsperhour;
-            return new Speed(value, SpeedUnit.YardPerHour);
+            return new Speed(yardsperhour, SpeedUnit.YardPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerMinute(QuantityValue yardsperminute)
+        public static Speed FromYardsPerMinute(double yardsperminute)
         {
-            double value = (double) yardsperminute;
-            return new Speed(value, SpeedUnit.YardPerMinute);
+            return new Speed(yardsperminute, SpeedUnit.YardPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerSecond(QuantityValue yardspersecond)
+        public static Speed FromYardsPerSecond(double yardspersecond)
         {
-            double value = (double) yardspersecond;
-            return new Speed(value, SpeedUnit.YardPerSecond);
+            return new Speed(yardspersecond, SpeedUnit.YardPerSecond);
         }
 
         /// <summary>
@@ -824,9 +791,9 @@ public static Speed FromYardsPerSecond(QuantityValue yardspersecond)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Speed unit value.</returns>
-        public static Speed From(QuantityValue value, SpeedUnit fromUnit)
+        public static Speed From(double value, SpeedUnit fromUnit)
         {
-            return new Speed((double)value, fromUnit);
+            return new Speed(value, fromUnit);
         }
 
         #endregion
@@ -1307,15 +1274,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is SpeedUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpeedUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is SpeedUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpeedUnit)} is supported.", nameof(unit));
@@ -1494,18 +1452,6 @@ public Speed ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<SpeedUnit> IQuantity<SpeedUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not SpeedUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(SpeedUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
index e229c4b67a..b5667ffc11 100644
--- a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct StandardVolumeFlow :
-        IArithmeticQuantity<StandardVolumeFlow, StandardVolumeFlowUnit, double>,
+        IArithmeticQuantity<StandardVolumeFlow, StandardVolumeFlowUnit>,
         IComparable,
         IComparable<StandardVolumeFlow>,
         IConvertible,
@@ -155,7 +155,7 @@ public StandardVolumeFlow(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -285,90 +285,81 @@ public static string GetAbbreviation(StandardVolumeFlowUnit unit, IFormatProvide
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(QuantityValue standardcubiccentimetersperminute)
+        public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(double standardcubiccentimetersperminute)
         {
-            double value = (double) standardcubiccentimetersperminute;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
+            return new StandardVolumeFlow(standardcubiccentimetersperminute, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicFeetPerHour(QuantityValue standardcubicfeetperhour)
+        public static StandardVolumeFlow FromStandardCubicFeetPerHour(double standardcubicfeetperhour)
         {
-            double value = (double) standardcubicfeetperhour;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerHour);
+            return new StandardVolumeFlow(standardcubicfeetperhour, StandardVolumeFlowUnit.StandardCubicFootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicFeetPerMinute(QuantityValue standardcubicfeetperminute)
+        public static StandardVolumeFlow FromStandardCubicFeetPerMinute(double standardcubicfeetperminute)
         {
-            double value = (double) standardcubicfeetperminute;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerMinute);
+            return new StandardVolumeFlow(standardcubicfeetperminute, StandardVolumeFlowUnit.StandardCubicFootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicFeetPerSecond(QuantityValue standardcubicfeetpersecond)
+        public static StandardVolumeFlow FromStandardCubicFeetPerSecond(double standardcubicfeetpersecond)
         {
-            double value = (double) standardcubicfeetpersecond;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerSecond);
+            return new StandardVolumeFlow(standardcubicfeetpersecond, StandardVolumeFlowUnit.StandardCubicFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicMetersPerDay(QuantityValue standardcubicmetersperday)
+        public static StandardVolumeFlow FromStandardCubicMetersPerDay(double standardcubicmetersperday)
         {
-            double value = (double) standardcubicmetersperday;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerDay);
+            return new StandardVolumeFlow(standardcubicmetersperday, StandardVolumeFlowUnit.StandardCubicMeterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicMetersPerHour(QuantityValue standardcubicmetersperhour)
+        public static StandardVolumeFlow FromStandardCubicMetersPerHour(double standardcubicmetersperhour)
         {
-            double value = (double) standardcubicmetersperhour;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerHour);
+            return new StandardVolumeFlow(standardcubicmetersperhour, StandardVolumeFlowUnit.StandardCubicMeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicMetersPerMinute(QuantityValue standardcubicmetersperminute)
+        public static StandardVolumeFlow FromStandardCubicMetersPerMinute(double standardcubicmetersperminute)
         {
-            double value = (double) standardcubicmetersperminute;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
+            return new StandardVolumeFlow(standardcubicmetersperminute, StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicMetersPerSecond(QuantityValue standardcubicmeterspersecond)
+        public static StandardVolumeFlow FromStandardCubicMetersPerSecond(double standardcubicmeterspersecond)
         {
-            double value = (double) standardcubicmeterspersecond;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
+            return new StandardVolumeFlow(standardcubicmeterspersecond, StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardLiterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardLitersPerMinute(QuantityValue standardlitersperminute)
+        public static StandardVolumeFlow FromStandardLitersPerMinute(double standardlitersperminute)
         {
-            double value = (double) standardlitersperminute;
-            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardLiterPerMinute);
+            return new StandardVolumeFlow(standardlitersperminute, StandardVolumeFlowUnit.StandardLiterPerMinute);
         }
 
         /// <summary>
@@ -377,9 +368,9 @@ public static StandardVolumeFlow FromStandardLitersPerMinute(QuantityValue stand
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>StandardVolumeFlow unit value.</returns>
-        public static StandardVolumeFlow From(QuantityValue value, StandardVolumeFlowUnit fromUnit)
+        public static StandardVolumeFlow From(double value, StandardVolumeFlowUnit fromUnit)
         {
-            return new StandardVolumeFlow((double)value, fromUnit);
+            return new StandardVolumeFlow(value, fromUnit);
         }
 
         #endregion
@@ -790,15 +781,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is StandardVolumeFlowUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(StandardVolumeFlowUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is StandardVolumeFlowUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(StandardVolumeFlowUnit)} is supported.", nameof(unit));
@@ -929,18 +911,6 @@ public StandardVolumeFlow ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<StandardVolumeFlowUnit> IQuantity<StandardVolumeFlowUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not StandardVolumeFlowUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(StandardVolumeFlowUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
index 9b89fd2f04..c3d224ce77 100644
--- a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Temperature :
-        IQuantity<Temperature, TemperatureUnit, double>,
+        IQuantity<Temperature, TemperatureUnit>,
         IComparable,
         IComparable<Temperature>,
         IConvertible,
@@ -153,7 +153,7 @@ public Temperature(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -290,100 +290,90 @@ public static string GetAbbreviation(TemperatureUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesCelsius(QuantityValue degreescelsius)
+        public static Temperature FromDegreesCelsius(double degreescelsius)
         {
-            double value = (double) degreescelsius;
-            return new Temperature(value, TemperatureUnit.DegreeCelsius);
+            return new Temperature(degreescelsius, TemperatureUnit.DegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeDelisle"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesDelisle(QuantityValue degreesdelisle)
+        public static Temperature FromDegreesDelisle(double degreesdelisle)
         {
-            double value = (double) degreesdelisle;
-            return new Temperature(value, TemperatureUnit.DegreeDelisle);
+            return new Temperature(degreesdelisle, TemperatureUnit.DegreeDelisle);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesFahrenheit(QuantityValue degreesfahrenheit)
+        public static Temperature FromDegreesFahrenheit(double degreesfahrenheit)
         {
-            double value = (double) degreesfahrenheit;
-            return new Temperature(value, TemperatureUnit.DegreeFahrenheit);
+            return new Temperature(degreesfahrenheit, TemperatureUnit.DegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeNewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesNewton(QuantityValue degreesnewton)
+        public static Temperature FromDegreesNewton(double degreesnewton)
         {
-            double value = (double) degreesnewton;
-            return new Temperature(value, TemperatureUnit.DegreeNewton);
+            return new Temperature(degreesnewton, TemperatureUnit.DegreeNewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeRankine"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesRankine(QuantityValue degreesrankine)
+        public static Temperature FromDegreesRankine(double degreesrankine)
         {
-            double value = (double) degreesrankine;
-            return new Temperature(value, TemperatureUnit.DegreeRankine);
+            return new Temperature(degreesrankine, TemperatureUnit.DegreeRankine);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeReaumur"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesReaumur(QuantityValue degreesreaumur)
+        public static Temperature FromDegreesReaumur(double degreesreaumur)
         {
-            double value = (double) degreesreaumur;
-            return new Temperature(value, TemperatureUnit.DegreeReaumur);
+            return new Temperature(degreesreaumur, TemperatureUnit.DegreeReaumur);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeRoemer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesRoemer(QuantityValue degreesroemer)
+        public static Temperature FromDegreesRoemer(double degreesroemer)
         {
-            double value = (double) degreesroemer;
-            return new Temperature(value, TemperatureUnit.DegreeRoemer);
+            return new Temperature(degreesroemer, TemperatureUnit.DegreeRoemer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.Kelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromKelvins(QuantityValue kelvins)
+        public static Temperature FromKelvins(double kelvins)
         {
-            double value = (double) kelvins;
-            return new Temperature(value, TemperatureUnit.Kelvin);
+            return new Temperature(kelvins, TemperatureUnit.Kelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.MillidegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromMillidegreesCelsius(QuantityValue millidegreescelsius)
+        public static Temperature FromMillidegreesCelsius(double millidegreescelsius)
         {
-            double value = (double) millidegreescelsius;
-            return new Temperature(value, TemperatureUnit.MillidegreeCelsius);
+            return new Temperature(millidegreescelsius, TemperatureUnit.MillidegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.SolarTemperature"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromSolarTemperatures(QuantityValue solartemperatures)
+        public static Temperature FromSolarTemperatures(double solartemperatures)
         {
-            double value = (double) solartemperatures;
-            return new Temperature(value, TemperatureUnit.SolarTemperature);
+            return new Temperature(solartemperatures, TemperatureUnit.SolarTemperature);
         }
 
         /// <summary>
@@ -392,9 +382,9 @@ public static Temperature FromSolarTemperatures(QuantityValue solartemperatures)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Temperature unit value.</returns>
-        public static Temperature From(QuantityValue value, TemperatureUnit fromUnit)
+        public static Temperature From(double value, TemperatureUnit fromUnit)
         {
-            return new Temperature((double)value, fromUnit);
+            return new Temperature(value, fromUnit);
         }
 
         #endregion
@@ -759,15 +749,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is TemperatureUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is TemperatureUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureUnit)} is supported.", nameof(unit));
@@ -900,18 +881,6 @@ public Temperature ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TemperatureUnit> IQuantity<TemperatureUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not TemperatureUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
index 3a397fbf7c..e50c577e4d 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct TemperatureChangeRate :
-        IArithmeticQuantity<TemperatureChangeRate, TemperatureChangeRateUnit, double>,
+        IArithmeticQuantity<TemperatureChangeRate, TemperatureChangeRateUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<TemperatureChangeRate, Duration, TemperatureDelta>,
         IMultiplyOperators<TemperatureChangeRate, TimeSpan, TemperatureDelta>,
@@ -163,7 +163,7 @@ public TemperatureChangeRate(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -300,100 +300,90 @@ public static string GetAbbreviation(TemperatureChangeRateUnit unit, IFormatProv
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(QuantityValue centidegreescelsiuspersecond)
+        public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(double centidegreescelsiuspersecond)
         {
-            double value = (double) centidegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(centidegreescelsiuspersecond, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(QuantityValue decadegreescelsiuspersecond)
+        public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(double decadegreescelsiuspersecond)
         {
-            double value = (double) decadegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(decadegreescelsiuspersecond, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(QuantityValue decidegreescelsiuspersecond)
+        public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(double decidegreescelsiuspersecond)
         {
-            double value = (double) decidegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(decidegreescelsiuspersecond, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDegreesCelsiusPerMinute(QuantityValue degreescelsiusperminute)
+        public static TemperatureChangeRate FromDegreesCelsiusPerMinute(double degreescelsiusperminute)
         {
-            double value = (double) degreescelsiusperminute;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
+            return new TemperatureChangeRate(degreescelsiusperminute, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDegreesCelsiusPerSecond(QuantityValue degreescelsiuspersecond)
+        public static TemperatureChangeRate FromDegreesCelsiusPerSecond(double degreescelsiuspersecond)
         {
-            double value = (double) degreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(degreescelsiuspersecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(QuantityValue hectodegreescelsiuspersecond)
+        public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(double hectodegreescelsiuspersecond)
         {
-            double value = (double) hectodegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(hectodegreescelsiuspersecond, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(QuantityValue kilodegreescelsiuspersecond)
+        public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(double kilodegreescelsiuspersecond)
         {
-            double value = (double) kilodegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(kilodegreescelsiuspersecond, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(QuantityValue microdegreescelsiuspersecond)
+        public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(double microdegreescelsiuspersecond)
         {
-            double value = (double) microdegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(microdegreescelsiuspersecond, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(QuantityValue millidegreescelsiuspersecond)
+        public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(double millidegreescelsiuspersecond)
         {
-            double value = (double) millidegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(millidegreescelsiuspersecond, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(QuantityValue nanodegreescelsiuspersecond)
+        public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanodegreescelsiuspersecond)
         {
-            double value = (double) nanodegreescelsiuspersecond;
-            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(nanodegreescelsiuspersecond, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
         }
 
         /// <summary>
@@ -402,9 +392,9 @@ public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(QuantityValu
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>TemperatureChangeRate unit value.</returns>
-        public static TemperatureChangeRate From(QuantityValue value, TemperatureChangeRateUnit fromUnit)
+        public static TemperatureChangeRate From(double value, TemperatureChangeRateUnit fromUnit)
         {
-            return new TemperatureChangeRate((double)value, fromUnit);
+            return new TemperatureChangeRate(value, fromUnit);
         }
 
         #endregion
@@ -837,15 +827,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is TemperatureChangeRateUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureChangeRateUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is TemperatureChangeRateUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureChangeRateUnit)} is supported.", nameof(unit));
@@ -978,18 +959,6 @@ public TemperatureChangeRate ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TemperatureChangeRateUnit> IQuantity<TemperatureChangeRateUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not TemperatureChangeRateUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureChangeRateUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
index 96d1d1fdf1..ea0728ccc2 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct TemperatureDelta :
-        IArithmeticQuantity<TemperatureDelta, TemperatureDeltaUnit, double>,
+        IArithmeticQuantity<TemperatureDelta, TemperatureDeltaUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<TemperatureDelta, Entropy, Energy>,
         IDivisionOperators<TemperatureDelta, TemperatureGradient, Length>,
@@ -165,7 +165,7 @@ public TemperatureDelta(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -295,90 +295,81 @@ public static string GetAbbreviation(TemperatureDeltaUnit unit, IFormatProvider?
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesCelsius(QuantityValue degreescelsius)
+        public static TemperatureDelta FromDegreesCelsius(double degreescelsius)
         {
-            double value = (double) degreescelsius;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeCelsius);
+            return new TemperatureDelta(degreescelsius, TemperatureDeltaUnit.DegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeDelisle"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesDelisle(QuantityValue degreesdelisle)
+        public static TemperatureDelta FromDegreesDelisle(double degreesdelisle)
         {
-            double value = (double) degreesdelisle;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeDelisle);
+            return new TemperatureDelta(degreesdelisle, TemperatureDeltaUnit.DegreeDelisle);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesFahrenheit(QuantityValue degreesfahrenheit)
+        public static TemperatureDelta FromDegreesFahrenheit(double degreesfahrenheit)
         {
-            double value = (double) degreesfahrenheit;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeFahrenheit);
+            return new TemperatureDelta(degreesfahrenheit, TemperatureDeltaUnit.DegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeNewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesNewton(QuantityValue degreesnewton)
+        public static TemperatureDelta FromDegreesNewton(double degreesnewton)
         {
-            double value = (double) degreesnewton;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeNewton);
+            return new TemperatureDelta(degreesnewton, TemperatureDeltaUnit.DegreeNewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeRankine"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesRankine(QuantityValue degreesrankine)
+        public static TemperatureDelta FromDegreesRankine(double degreesrankine)
         {
-            double value = (double) degreesrankine;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRankine);
+            return new TemperatureDelta(degreesrankine, TemperatureDeltaUnit.DegreeRankine);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeReaumur"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesReaumur(QuantityValue degreesreaumur)
+        public static TemperatureDelta FromDegreesReaumur(double degreesreaumur)
         {
-            double value = (double) degreesreaumur;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeReaumur);
+            return new TemperatureDelta(degreesreaumur, TemperatureDeltaUnit.DegreeReaumur);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeRoemer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesRoemer(QuantityValue degreesroemer)
+        public static TemperatureDelta FromDegreesRoemer(double degreesroemer)
         {
-            double value = (double) degreesroemer;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRoemer);
+            return new TemperatureDelta(degreesroemer, TemperatureDeltaUnit.DegreeRoemer);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.Kelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromKelvins(QuantityValue kelvins)
+        public static TemperatureDelta FromKelvins(double kelvins)
         {
-            double value = (double) kelvins;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.Kelvin);
+            return new TemperatureDelta(kelvins, TemperatureDeltaUnit.Kelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.MillidegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromMillidegreesCelsius(QuantityValue millidegreescelsius)
+        public static TemperatureDelta FromMillidegreesCelsius(double millidegreescelsius)
         {
-            double value = (double) millidegreescelsius;
-            return new TemperatureDelta(value, TemperatureDeltaUnit.MillidegreeCelsius);
+            return new TemperatureDelta(millidegreescelsius, TemperatureDeltaUnit.MillidegreeCelsius);
         }
 
         /// <summary>
@@ -387,9 +378,9 @@ public static TemperatureDelta FromMillidegreesCelsius(QuantityValue millidegree
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>TemperatureDelta unit value.</returns>
-        public static TemperatureDelta From(QuantityValue value, TemperatureDeltaUnit fromUnit)
+        public static TemperatureDelta From(double value, TemperatureDeltaUnit fromUnit)
         {
-            return new TemperatureDelta((double)value, fromUnit);
+            return new TemperatureDelta(value, fromUnit);
         }
 
         #endregion
@@ -834,15 +825,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is TemperatureDeltaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureDeltaUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is TemperatureDeltaUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureDeltaUnit)} is supported.", nameof(unit));
@@ -973,18 +955,6 @@ public TemperatureDelta ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TemperatureDeltaUnit> IQuantity<TemperatureDeltaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not TemperatureDeltaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureDeltaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
index cb9e6d6e36..bd3d6405be 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct TemperatureGradient :
-        IArithmeticQuantity<TemperatureGradient, TemperatureGradientUnit, double>,
+        IArithmeticQuantity<TemperatureGradient, TemperatureGradientUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<TemperatureGradient, Length, TemperatureDelta>,
 #endif
@@ -156,7 +156,7 @@ public TemperatureGradient(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -251,40 +251,36 @@ public static string GetAbbreviation(TemperatureGradientUnit unit, IFormatProvid
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeCelsiusPerKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureGradient FromDegreesCelsiusPerKilometer(QuantityValue degreescelsiusperkilometer)
+        public static TemperatureGradient FromDegreesCelsiusPerKilometer(double degreescelsiusperkilometer)
         {
-            double value = (double) degreescelsiusperkilometer;
-            return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerKilometer);
+            return new TemperatureGradient(degreescelsiusperkilometer, TemperatureGradientUnit.DegreeCelsiusPerKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeCelsiusPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureGradient FromDegreesCelsiusPerMeter(QuantityValue degreescelsiuspermeter)
+        public static TemperatureGradient FromDegreesCelsiusPerMeter(double degreescelsiuspermeter)
         {
-            double value = (double) degreescelsiuspermeter;
-            return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerMeter);
+            return new TemperatureGradient(degreescelsiuspermeter, TemperatureGradientUnit.DegreeCelsiusPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeFahrenheitPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureGradient FromDegreesFahrenheitPerFoot(QuantityValue degreesfahrenheitperfoot)
+        public static TemperatureGradient FromDegreesFahrenheitPerFoot(double degreesfahrenheitperfoot)
         {
-            double value = (double) degreesfahrenheitperfoot;
-            return new TemperatureGradient(value, TemperatureGradientUnit.DegreeFahrenheitPerFoot);
+            return new TemperatureGradient(degreesfahrenheitperfoot, TemperatureGradientUnit.DegreeFahrenheitPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.KelvinPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureGradient FromKelvinsPerMeter(QuantityValue kelvinspermeter)
+        public static TemperatureGradient FromKelvinsPerMeter(double kelvinspermeter)
         {
-            double value = (double) kelvinspermeter;
-            return new TemperatureGradient(value, TemperatureGradientUnit.KelvinPerMeter);
+            return new TemperatureGradient(kelvinspermeter, TemperatureGradientUnit.KelvinPerMeter);
         }
 
         /// <summary>
@@ -293,9 +289,9 @@ public static TemperatureGradient FromKelvinsPerMeter(QuantityValue kelvinsperme
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>TemperatureGradient unit value.</returns>
-        public static TemperatureGradient From(QuantityValue value, TemperatureGradientUnit fromUnit)
+        public static TemperatureGradient From(double value, TemperatureGradientUnit fromUnit)
         {
-            return new TemperatureGradient((double)value, fromUnit);
+            return new TemperatureGradient(value, fromUnit);
         }
 
         #endregion
@@ -716,15 +712,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is TemperatureGradientUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureGradientUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is TemperatureGradientUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureGradientUnit)} is supported.", nameof(unit));
@@ -845,18 +832,6 @@ public TemperatureGradient ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TemperatureGradientUnit> IQuantity<TemperatureGradientUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not TemperatureGradientUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TemperatureGradientUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
index 5436d4b4da..7d523f9769 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct ThermalConductivity :
-        IArithmeticQuantity<ThermalConductivity, ThermalConductivityUnit, double>,
+        IArithmeticQuantity<ThermalConductivity, ThermalConductivityUnit>,
         IComparable,
         IComparable<ThermalConductivity>,
         IConvertible,
@@ -151,7 +151,7 @@ public ThermalConductivity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -232,20 +232,18 @@ public static string GetAbbreviation(ThermalConductivityUnit unit, IFormatProvid
         ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.BtuPerHourFootFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalConductivity FromBtusPerHourFootFahrenheit(QuantityValue btusperhourfootfahrenheit)
+        public static ThermalConductivity FromBtusPerHourFootFahrenheit(double btusperhourfootfahrenheit)
         {
-            double value = (double) btusperhourfootfahrenheit;
-            return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
+            return new ThermalConductivity(btusperhourfootfahrenheit, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.WattPerMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalConductivity FromWattsPerMeterKelvin(QuantityValue wattspermeterkelvin)
+        public static ThermalConductivity FromWattsPerMeterKelvin(double wattspermeterkelvin)
         {
-            double value = (double) wattspermeterkelvin;
-            return new ThermalConductivity(value, ThermalConductivityUnit.WattPerMeterKelvin);
+            return new ThermalConductivity(wattspermeterkelvin, ThermalConductivityUnit.WattPerMeterKelvin);
         }
 
         /// <summary>
@@ -254,9 +252,9 @@ public static ThermalConductivity FromWattsPerMeterKelvin(QuantityValue wattsper
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ThermalConductivity unit value.</returns>
-        public static ThermalConductivity From(QuantityValue value, ThermalConductivityUnit fromUnit)
+        public static ThermalConductivity From(double value, ThermalConductivityUnit fromUnit)
         {
-            return new ThermalConductivity((double)value, fromUnit);
+            return new ThermalConductivity(value, fromUnit);
         }
 
         #endregion
@@ -667,15 +665,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ThermalConductivityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalConductivityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ThermalConductivityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalConductivityUnit)} is supported.", nameof(unit));
@@ -792,18 +781,6 @@ public ThermalConductivity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ThermalConductivityUnit> IQuantity<ThermalConductivityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ThermalConductivityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalConductivityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
index 0a0a9698bf..d22876e53d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct ThermalResistance :
-        IArithmeticQuantity<ThermalResistance, ThermalResistanceUnit, double>,
+        IArithmeticQuantity<ThermalResistance, ThermalResistanceUnit>,
         IComparable,
         IComparable<ThermalResistance>,
         IConvertible,
@@ -152,7 +152,7 @@ public ThermalResistance(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -261,60 +261,54 @@ public static string GetAbbreviation(ThermalResistanceUnit unit, IFormatProvider
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(QuantityValue hoursquarefeetdegreesfahrenheitperbtu)
+        public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(double hoursquarefeetdegreesfahrenheitperbtu)
         {
-            double value = (double) hoursquarefeetdegreesfahrenheitperbtu;
-            return new ThermalResistance(value, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
+            return new ThermalResistance(hoursquarefeetdegreesfahrenheitperbtu, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(QuantityValue squarecentimeterhourdegreescelsiusperkilocalorie)
+        public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double squarecentimeterhourdegreescelsiusperkilocalorie)
         {
-            double value = (double) squarecentimeterhourdegreescelsiusperkilocalorie;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
+            return new ThermalResistance(squarecentimeterhourdegreescelsiusperkilocalorie, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareCentimeterKelvinPerWatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(QuantityValue squarecentimeterkelvinsperwatt)
+        public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(double squarecentimeterkelvinsperwatt)
         {
-            double value = (double) squarecentimeterkelvinsperwatt;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
+            return new ThermalResistance(squarecentimeterkelvinsperwatt, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(QuantityValue squaremeterdegreescelsiusperwatt)
+        public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(double squaremeterdegreescelsiusperwatt)
         {
-            double value = (double) squaremeterdegreescelsiusperwatt;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
+            return new ThermalResistance(squaremeterdegreescelsiusperwatt, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareMeterKelvinPerKilowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(QuantityValue squaremeterkelvinsperkilowatt)
+        public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(double squaremeterkelvinsperkilowatt)
         {
-            double value = (double) squaremeterkelvinsperkilowatt;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
+            return new ThermalResistance(squaremeterkelvinsperkilowatt, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareMeterKelvinPerWatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareMeterKelvinsPerWatt(QuantityValue squaremeterkelvinsperwatt)
+        public static ThermalResistance FromSquareMeterKelvinsPerWatt(double squaremeterkelvinsperwatt)
         {
-            double value = (double) squaremeterkelvinsperwatt;
-            return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerWatt);
+            return new ThermalResistance(squaremeterkelvinsperwatt, ThermalResistanceUnit.SquareMeterKelvinPerWatt);
         }
 
         /// <summary>
@@ -323,9 +317,9 @@ public static ThermalResistance FromSquareMeterKelvinsPerWatt(QuantityValue squa
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>ThermalResistance unit value.</returns>
-        public static ThermalResistance From(QuantityValue value, ThermalResistanceUnit fromUnit)
+        public static ThermalResistance From(double value, ThermalResistanceUnit fromUnit)
         {
-            return new ThermalResistance((double)value, fromUnit);
+            return new ThermalResistance(value, fromUnit);
         }
 
         #endregion
@@ -736,15 +730,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is ThermalResistanceUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalResistanceUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is ThermalResistanceUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalResistanceUnit)} is supported.", nameof(unit));
@@ -869,18 +854,6 @@ public ThermalResistance ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<ThermalResistanceUnit> IQuantity<ThermalResistanceUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not ThermalResistanceUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(ThermalResistanceUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
index 96128169ef..1541850784 100644
--- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Torque :
-        IArithmeticQuantity<Torque, TorqueUnit, double>,
+        IArithmeticQuantity<Torque, TorqueUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Torque, RotationalStiffness, Angle>,
         IDivisionOperators<Torque, Length, Force>,
@@ -180,7 +180,7 @@ public Torque(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -422,250 +422,225 @@ public static string GetAbbreviation(TorqueUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromGramForceCentimeters(QuantityValue gramforcecentimeters)
+        public static Torque FromGramForceCentimeters(double gramforcecentimeters)
         {
-            double value = (double) gramforcecentimeters;
-            return new Torque(value, TorqueUnit.GramForceCentimeter);
+            return new Torque(gramforcecentimeters, TorqueUnit.GramForceCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromGramForceMeters(QuantityValue gramforcemeters)
+        public static Torque FromGramForceMeters(double gramforcemeters)
         {
-            double value = (double) gramforcemeters;
-            return new Torque(value, TorqueUnit.GramForceMeter);
+            return new Torque(gramforcemeters, TorqueUnit.GramForceMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromGramForceMillimeters(QuantityValue gramforcemillimeters)
+        public static Torque FromGramForceMillimeters(double gramforcemillimeters)
         {
-            double value = (double) gramforcemillimeters;
-            return new Torque(value, TorqueUnit.GramForceMillimeter);
+            return new Torque(gramforcemillimeters, TorqueUnit.GramForceMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceCentimeters(QuantityValue kilogramforcecentimeters)
+        public static Torque FromKilogramForceCentimeters(double kilogramforcecentimeters)
         {
-            double value = (double) kilogramforcecentimeters;
-            return new Torque(value, TorqueUnit.KilogramForceCentimeter);
+            return new Torque(kilogramforcecentimeters, TorqueUnit.KilogramForceCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceMeters(QuantityValue kilogramforcemeters)
+        public static Torque FromKilogramForceMeters(double kilogramforcemeters)
         {
-            double value = (double) kilogramforcemeters;
-            return new Torque(value, TorqueUnit.KilogramForceMeter);
+            return new Torque(kilogramforcemeters, TorqueUnit.KilogramForceMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceMillimeters(QuantityValue kilogramforcemillimeters)
+        public static Torque FromKilogramForceMillimeters(double kilogramforcemillimeters)
         {
-            double value = (double) kilogramforcemillimeters;
-            return new Torque(value, TorqueUnit.KilogramForceMillimeter);
+            return new Torque(kilogramforcemillimeters, TorqueUnit.KilogramForceMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonCentimeters(QuantityValue kilonewtoncentimeters)
+        public static Torque FromKilonewtonCentimeters(double kilonewtoncentimeters)
         {
-            double value = (double) kilonewtoncentimeters;
-            return new Torque(value, TorqueUnit.KilonewtonCentimeter);
+            return new Torque(kilonewtoncentimeters, TorqueUnit.KilonewtonCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonMeters(QuantityValue kilonewtonmeters)
+        public static Torque FromKilonewtonMeters(double kilonewtonmeters)
         {
-            double value = (double) kilonewtonmeters;
-            return new Torque(value, TorqueUnit.KilonewtonMeter);
+            return new Torque(kilonewtonmeters, TorqueUnit.KilonewtonMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonMillimeters(QuantityValue kilonewtonmillimeters)
+        public static Torque FromKilonewtonMillimeters(double kilonewtonmillimeters)
         {
-            double value = (double) kilonewtonmillimeters;
-            return new Torque(value, TorqueUnit.KilonewtonMillimeter);
+            return new Torque(kilonewtonmillimeters, TorqueUnit.KilonewtonMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilopoundForceFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilopoundForceFeet(QuantityValue kilopoundforcefeet)
+        public static Torque FromKilopoundForceFeet(double kilopoundforcefeet)
         {
-            double value = (double) kilopoundforcefeet;
-            return new Torque(value, TorqueUnit.KilopoundForceFoot);
+            return new Torque(kilopoundforcefeet, TorqueUnit.KilopoundForceFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilopoundForceInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilopoundForceInches(QuantityValue kilopoundforceinches)
+        public static Torque FromKilopoundForceInches(double kilopoundforceinches)
         {
-            double value = (double) kilopoundforceinches;
-            return new Torque(value, TorqueUnit.KilopoundForceInch);
+            return new Torque(kilopoundforceinches, TorqueUnit.KilopoundForceInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonCentimeters(QuantityValue meganewtoncentimeters)
+        public static Torque FromMeganewtonCentimeters(double meganewtoncentimeters)
         {
-            double value = (double) meganewtoncentimeters;
-            return new Torque(value, TorqueUnit.MeganewtonCentimeter);
+            return new Torque(meganewtoncentimeters, TorqueUnit.MeganewtonCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonMeters(QuantityValue meganewtonmeters)
+        public static Torque FromMeganewtonMeters(double meganewtonmeters)
         {
-            double value = (double) meganewtonmeters;
-            return new Torque(value, TorqueUnit.MeganewtonMeter);
+            return new Torque(meganewtonmeters, TorqueUnit.MeganewtonMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonMillimeters(QuantityValue meganewtonmillimeters)
+        public static Torque FromMeganewtonMillimeters(double meganewtonmillimeters)
         {
-            double value = (double) meganewtonmillimeters;
-            return new Torque(value, TorqueUnit.MeganewtonMillimeter);
+            return new Torque(meganewtonmillimeters, TorqueUnit.MeganewtonMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MegapoundForceFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMegapoundForceFeet(QuantityValue megapoundforcefeet)
+        public static Torque FromMegapoundForceFeet(double megapoundforcefeet)
         {
-            double value = (double) megapoundforcefeet;
-            return new Torque(value, TorqueUnit.MegapoundForceFoot);
+            return new Torque(megapoundforcefeet, TorqueUnit.MegapoundForceFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MegapoundForceInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMegapoundForceInches(QuantityValue megapoundforceinches)
+        public static Torque FromMegapoundForceInches(double megapoundforceinches)
         {
-            double value = (double) megapoundforceinches;
-            return new Torque(value, TorqueUnit.MegapoundForceInch);
+            return new Torque(megapoundforceinches, TorqueUnit.MegapoundForceInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonCentimeters(QuantityValue newtoncentimeters)
+        public static Torque FromNewtonCentimeters(double newtoncentimeters)
         {
-            double value = (double) newtoncentimeters;
-            return new Torque(value, TorqueUnit.NewtonCentimeter);
+            return new Torque(newtoncentimeters, TorqueUnit.NewtonCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonMeters(QuantityValue newtonmeters)
+        public static Torque FromNewtonMeters(double newtonmeters)
         {
-            double value = (double) newtonmeters;
-            return new Torque(value, TorqueUnit.NewtonMeter);
+            return new Torque(newtonmeters, TorqueUnit.NewtonMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonMillimeters(QuantityValue newtonmillimeters)
+        public static Torque FromNewtonMillimeters(double newtonmillimeters)
         {
-            double value = (double) newtonmillimeters;
-            return new Torque(value, TorqueUnit.NewtonMillimeter);
+            return new Torque(newtonmillimeters, TorqueUnit.NewtonMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundalFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundalFeet(QuantityValue poundalfeet)
+        public static Torque FromPoundalFeet(double poundalfeet)
         {
-            double value = (double) poundalfeet;
-            return new Torque(value, TorqueUnit.PoundalFoot);
+            return new Torque(poundalfeet, TorqueUnit.PoundalFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundForceFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundForceFeet(QuantityValue poundforcefeet)
+        public static Torque FromPoundForceFeet(double poundforcefeet)
         {
-            double value = (double) poundforcefeet;
-            return new Torque(value, TorqueUnit.PoundForceFoot);
+            return new Torque(poundforcefeet, TorqueUnit.PoundForceFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundForceInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundForceInches(QuantityValue poundforceinches)
+        public static Torque FromPoundForceInches(double poundforceinches)
         {
-            double value = (double) poundforceinches;
-            return new Torque(value, TorqueUnit.PoundForceInch);
+            return new Torque(poundforceinches, TorqueUnit.PoundForceInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceCentimeters(QuantityValue tonneforcecentimeters)
+        public static Torque FromTonneForceCentimeters(double tonneforcecentimeters)
         {
-            double value = (double) tonneforcecentimeters;
-            return new Torque(value, TorqueUnit.TonneForceCentimeter);
+            return new Torque(tonneforcecentimeters, TorqueUnit.TonneForceCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceMeters(QuantityValue tonneforcemeters)
+        public static Torque FromTonneForceMeters(double tonneforcemeters)
         {
-            double value = (double) tonneforcemeters;
-            return new Torque(value, TorqueUnit.TonneForceMeter);
+            return new Torque(tonneforcemeters, TorqueUnit.TonneForceMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceMillimeters(QuantityValue tonneforcemillimeters)
+        public static Torque FromTonneForceMillimeters(double tonneforcemillimeters)
         {
-            double value = (double) tonneforcemillimeters;
-            return new Torque(value, TorqueUnit.TonneForceMillimeter);
+            return new Torque(tonneforcemillimeters, TorqueUnit.TonneForceMillimeter);
         }
 
         /// <summary>
@@ -674,9 +649,9 @@ public static Torque FromTonneForceMillimeters(QuantityValue tonneforcemillimete
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Torque unit value.</returns>
-        public static Torque From(QuantityValue value, TorqueUnit fromUnit)
+        public static Torque From(double value, TorqueUnit fromUnit)
         {
-            return new Torque((double)value, fromUnit);
+            return new Torque(value, fromUnit);
         }
 
         #endregion
@@ -1115,15 +1090,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is TorqueUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorqueUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is TorqueUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorqueUnit)} is supported.", nameof(unit));
@@ -1286,18 +1252,6 @@ public Torque ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TorqueUnit> IQuantity<TorqueUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not TorqueUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorqueUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
index 1abe988cf9..3324414983 100644
--- a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct TorquePerLength :
-        IArithmeticQuantity<TorquePerLength, TorquePerLengthUnit, double>,
+        IArithmeticQuantity<TorquePerLength, TorquePerLengthUnit>,
         IComparable,
         IComparable<TorquePerLength>,
         IConvertible,
@@ -167,7 +167,7 @@ public TorquePerLength(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -381,210 +381,189 @@ public static string GetAbbreviation(TorquePerLengthUnit unit, IFormatProvider?
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilogramForceCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceCentimetersPerMeter(QuantityValue kilogramforcecentimeterspermeter)
+        public static TorquePerLength FromKilogramForceCentimetersPerMeter(double kilogramforcecentimeterspermeter)
         {
-            double value = (double) kilogramforcecentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
+            return new TorquePerLength(kilogramforcecentimeterspermeter, TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilogramForceMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceMetersPerMeter(QuantityValue kilogramforcemeterspermeter)
+        public static TorquePerLength FromKilogramForceMetersPerMeter(double kilogramforcemeterspermeter)
         {
-            double value = (double) kilogramforcemeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMeterPerMeter);
+            return new TorquePerLength(kilogramforcemeterspermeter, TorquePerLengthUnit.KilogramForceMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilogramForceMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceMillimetersPerMeter(QuantityValue kilogramforcemillimeterspermeter)
+        public static TorquePerLength FromKilogramForceMillimetersPerMeter(double kilogramforcemillimeterspermeter)
         {
-            double value = (double) kilogramforcemillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
+            return new TorquePerLength(kilogramforcemillimeterspermeter, TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilonewtonCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonCentimetersPerMeter(QuantityValue kilonewtoncentimeterspermeter)
+        public static TorquePerLength FromKilonewtonCentimetersPerMeter(double kilonewtoncentimeterspermeter)
         {
-            double value = (double) kilonewtoncentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
+            return new TorquePerLength(kilonewtoncentimeterspermeter, TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilonewtonMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonMetersPerMeter(QuantityValue kilonewtonmeterspermeter)
+        public static TorquePerLength FromKilonewtonMetersPerMeter(double kilonewtonmeterspermeter)
         {
-            double value = (double) kilonewtonmeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMeterPerMeter);
+            return new TorquePerLength(kilonewtonmeterspermeter, TorquePerLengthUnit.KilonewtonMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilonewtonMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonMillimetersPerMeter(QuantityValue kilonewtonmillimeterspermeter)
+        public static TorquePerLength FromKilonewtonMillimetersPerMeter(double kilonewtonmillimeterspermeter)
         {
-            double value = (double) kilonewtonmillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
+            return new TorquePerLength(kilonewtonmillimeterspermeter, TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilopoundForceFootPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilopoundForceFeetPerFoot(QuantityValue kilopoundforcefeetperfoot)
+        public static TorquePerLength FromKilopoundForceFeetPerFoot(double kilopoundforcefeetperfoot)
         {
-            double value = (double) kilopoundforcefeetperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceFootPerFoot);
+            return new TorquePerLength(kilopoundforcefeetperfoot, TorquePerLengthUnit.KilopoundForceFootPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilopoundForceInchPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilopoundForceInchesPerFoot(QuantityValue kilopoundforceinchesperfoot)
+        public static TorquePerLength FromKilopoundForceInchesPerFoot(double kilopoundforceinchesperfoot)
         {
-            double value = (double) kilopoundforceinchesperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceInchPerFoot);
+            return new TorquePerLength(kilopoundforceinchesperfoot, TorquePerLengthUnit.KilopoundForceInchPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MeganewtonCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonCentimetersPerMeter(QuantityValue meganewtoncentimeterspermeter)
+        public static TorquePerLength FromMeganewtonCentimetersPerMeter(double meganewtoncentimeterspermeter)
         {
-            double value = (double) meganewtoncentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
+            return new TorquePerLength(meganewtoncentimeterspermeter, TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MeganewtonMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonMetersPerMeter(QuantityValue meganewtonmeterspermeter)
+        public static TorquePerLength FromMeganewtonMetersPerMeter(double meganewtonmeterspermeter)
         {
-            double value = (double) meganewtonmeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMeterPerMeter);
+            return new TorquePerLength(meganewtonmeterspermeter, TorquePerLengthUnit.MeganewtonMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MeganewtonMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonMillimetersPerMeter(QuantityValue meganewtonmillimeterspermeter)
+        public static TorquePerLength FromMeganewtonMillimetersPerMeter(double meganewtonmillimeterspermeter)
         {
-            double value = (double) meganewtonmillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
+            return new TorquePerLength(meganewtonmillimeterspermeter, TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MegapoundForceFootPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMegapoundForceFeetPerFoot(QuantityValue megapoundforcefeetperfoot)
+        public static TorquePerLength FromMegapoundForceFeetPerFoot(double megapoundforcefeetperfoot)
         {
-            double value = (double) megapoundforcefeetperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceFootPerFoot);
+            return new TorquePerLength(megapoundforcefeetperfoot, TorquePerLengthUnit.MegapoundForceFootPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MegapoundForceInchPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMegapoundForceInchesPerFoot(QuantityValue megapoundforceinchesperfoot)
+        public static TorquePerLength FromMegapoundForceInchesPerFoot(double megapoundforceinchesperfoot)
         {
-            double value = (double) megapoundforceinchesperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceInchPerFoot);
+            return new TorquePerLength(megapoundforceinchesperfoot, TorquePerLengthUnit.MegapoundForceInchPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.NewtonCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonCentimetersPerMeter(QuantityValue newtoncentimeterspermeter)
+        public static TorquePerLength FromNewtonCentimetersPerMeter(double newtoncentimeterspermeter)
         {
-            double value = (double) newtoncentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.NewtonCentimeterPerMeter);
+            return new TorquePerLength(newtoncentimeterspermeter, TorquePerLengthUnit.NewtonCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.NewtonMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonMetersPerMeter(QuantityValue newtonmeterspermeter)
+        public static TorquePerLength FromNewtonMetersPerMeter(double newtonmeterspermeter)
         {
-            double value = (double) newtonmeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.NewtonMeterPerMeter);
+            return new TorquePerLength(newtonmeterspermeter, TorquePerLengthUnit.NewtonMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.NewtonMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonMillimetersPerMeter(QuantityValue newtonmillimeterspermeter)
+        public static TorquePerLength FromNewtonMillimetersPerMeter(double newtonmillimeterspermeter)
         {
-            double value = (double) newtonmillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.NewtonMillimeterPerMeter);
+            return new TorquePerLength(newtonmillimeterspermeter, TorquePerLengthUnit.NewtonMillimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.PoundForceFootPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromPoundForceFeetPerFoot(QuantityValue poundforcefeetperfoot)
+        public static TorquePerLength FromPoundForceFeetPerFoot(double poundforcefeetperfoot)
         {
-            double value = (double) poundforcefeetperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.PoundForceFootPerFoot);
+            return new TorquePerLength(poundforcefeetperfoot, TorquePerLengthUnit.PoundForceFootPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.PoundForceInchPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromPoundForceInchesPerFoot(QuantityValue poundforceinchesperfoot)
+        public static TorquePerLength FromPoundForceInchesPerFoot(double poundforceinchesperfoot)
         {
-            double value = (double) poundforceinchesperfoot;
-            return new TorquePerLength(value, TorquePerLengthUnit.PoundForceInchPerFoot);
+            return new TorquePerLength(poundforceinchesperfoot, TorquePerLengthUnit.PoundForceInchPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.TonneForceCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceCentimetersPerMeter(QuantityValue tonneforcecentimeterspermeter)
+        public static TorquePerLength FromTonneForceCentimetersPerMeter(double tonneforcecentimeterspermeter)
         {
-            double value = (double) tonneforcecentimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceCentimeterPerMeter);
+            return new TorquePerLength(tonneforcecentimeterspermeter, TorquePerLengthUnit.TonneForceCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.TonneForceMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceMetersPerMeter(QuantityValue tonneforcemeterspermeter)
+        public static TorquePerLength FromTonneForceMetersPerMeter(double tonneforcemeterspermeter)
         {
-            double value = (double) tonneforcemeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMeterPerMeter);
+            return new TorquePerLength(tonneforcemeterspermeter, TorquePerLengthUnit.TonneForceMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.TonneForceMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceMillimetersPerMeter(QuantityValue tonneforcemillimeterspermeter)
+        public static TorquePerLength FromTonneForceMillimetersPerMeter(double tonneforcemillimeterspermeter)
         {
-            double value = (double) tonneforcemillimeterspermeter;
-            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMillimeterPerMeter);
+            return new TorquePerLength(tonneforcemillimeterspermeter, TorquePerLengthUnit.TonneForceMillimeterPerMeter);
         }
 
         /// <summary>
@@ -593,9 +572,9 @@ public static TorquePerLength FromTonneForceMillimetersPerMeter(QuantityValue to
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>TorquePerLength unit value.</returns>
-        public static TorquePerLength From(QuantityValue value, TorquePerLengthUnit fromUnit)
+        public static TorquePerLength From(double value, TorquePerLengthUnit fromUnit)
         {
-            return new TorquePerLength((double)value, fromUnit);
+            return new TorquePerLength(value, fromUnit);
         }
 
         #endregion
@@ -1006,15 +985,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is TorquePerLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorquePerLengthUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is TorquePerLengthUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorquePerLengthUnit)} is supported.", nameof(unit));
@@ -1169,18 +1139,6 @@ public TorquePerLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TorquePerLengthUnit> IQuantity<TorquePerLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not TorquePerLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TorquePerLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
index 17caf386c4..ab02056d19 100644
--- a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct Turbidity :
-        IArithmeticQuantity<Turbidity, TurbidityUnit, double>,
+        IArithmeticQuantity<Turbidity, TurbidityUnit>,
         IComparable,
         IComparable<Turbidity>,
         IConvertible,
@@ -150,7 +150,7 @@ public Turbidity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -224,10 +224,9 @@ public static string GetAbbreviation(TurbidityUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="Turbidity"/> from <see cref="TurbidityUnit.NTU"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Turbidity FromNTU(QuantityValue ntu)
+        public static Turbidity FromNTU(double ntu)
         {
-            double value = (double) ntu;
-            return new Turbidity(value, TurbidityUnit.NTU);
+            return new Turbidity(ntu, TurbidityUnit.NTU);
         }
 
         /// <summary>
@@ -236,9 +235,9 @@ public static Turbidity FromNTU(QuantityValue ntu)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Turbidity unit value.</returns>
-        public static Turbidity From(QuantityValue value, TurbidityUnit fromUnit)
+        public static Turbidity From(double value, TurbidityUnit fromUnit)
         {
-            return new Turbidity((double)value, fromUnit);
+            return new Turbidity(value, fromUnit);
         }
 
         #endregion
@@ -649,15 +648,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is TurbidityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TurbidityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is TurbidityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TurbidityUnit)} is supported.", nameof(unit));
@@ -772,18 +762,6 @@ public Turbidity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<TurbidityUnit> IQuantity<TurbidityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not TurbidityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(TurbidityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
index c28ce6e569..dbfacd2822 100644
--- a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct VitaminA :
-        IArithmeticQuantity<VitaminA, VitaminAUnit, double>,
+        IArithmeticQuantity<VitaminA, VitaminAUnit>,
         IComparable,
         IComparable<VitaminA>,
         IConvertible,
@@ -147,7 +147,7 @@ public VitaminA(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -221,10 +221,9 @@ public static string GetAbbreviation(VitaminAUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="VitaminA"/> from <see cref="VitaminAUnit.InternationalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VitaminA FromInternationalUnits(QuantityValue internationalunits)
+        public static VitaminA FromInternationalUnits(double internationalunits)
         {
-            double value = (double) internationalunits;
-            return new VitaminA(value, VitaminAUnit.InternationalUnit);
+            return new VitaminA(internationalunits, VitaminAUnit.InternationalUnit);
         }
 
         /// <summary>
@@ -233,9 +232,9 @@ public static VitaminA FromInternationalUnits(QuantityValue internationalunits)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VitaminA unit value.</returns>
-        public static VitaminA From(QuantityValue value, VitaminAUnit fromUnit)
+        public static VitaminA From(double value, VitaminAUnit fromUnit)
         {
-            return new VitaminA((double)value, fromUnit);
+            return new VitaminA(value, fromUnit);
         }
 
         #endregion
@@ -646,15 +645,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is VitaminAUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VitaminAUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is VitaminAUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VitaminAUnit)} is supported.", nameof(unit));
@@ -769,18 +759,6 @@ public VitaminA ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VitaminAUnit> IQuantity<VitaminAUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not VitaminAUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VitaminAUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
index 0f241b68e8..130cbc626b 100644
--- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct Volume :
-        IArithmeticQuantity<Volume, VolumeUnit, double>,
+        IArithmeticQuantity<Volume, VolumeUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Volume, Length, Area>,
         IMultiplyOperators<Volume, EnergyDensity, Energy>,
@@ -212,7 +212,7 @@ public Volume(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -657,540 +657,486 @@ public static string GetAbbreviation(VolumeUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.AcreFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromAcreFeet(QuantityValue acrefeet)
+        public static Volume FromAcreFeet(double acrefeet)
         {
-            double value = (double) acrefeet;
-            return new Volume(value, VolumeUnit.AcreFoot);
+            return new Volume(acrefeet, VolumeUnit.AcreFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.AuTablespoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromAuTablespoons(QuantityValue autablespoons)
+        public static Volume FromAuTablespoons(double autablespoons)
         {
-            double value = (double) autablespoons;
-            return new Volume(value, VolumeUnit.AuTablespoon);
+            return new Volume(autablespoons, VolumeUnit.AuTablespoon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.BoardFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromBoardFeet(QuantityValue boardfeet)
+        public static Volume FromBoardFeet(double boardfeet)
         {
-            double value = (double) boardfeet;
-            return new Volume(value, VolumeUnit.BoardFoot);
+            return new Volume(boardfeet, VolumeUnit.BoardFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Centiliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCentiliters(QuantityValue centiliters)
+        public static Volume FromCentiliters(double centiliters)
         {
-            double value = (double) centiliters;
-            return new Volume(value, VolumeUnit.Centiliter);
+            return new Volume(centiliters, VolumeUnit.Centiliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicCentimeters(QuantityValue cubiccentimeters)
+        public static Volume FromCubicCentimeters(double cubiccentimeters)
         {
-            double value = (double) cubiccentimeters;
-            return new Volume(value, VolumeUnit.CubicCentimeter);
+            return new Volume(cubiccentimeters, VolumeUnit.CubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicDecimeters(QuantityValue cubicdecimeters)
+        public static Volume FromCubicDecimeters(double cubicdecimeters)
         {
-            double value = (double) cubicdecimeters;
-            return new Volume(value, VolumeUnit.CubicDecimeter);
+            return new Volume(cubicdecimeters, VolumeUnit.CubicDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicFeet(QuantityValue cubicfeet)
+        public static Volume FromCubicFeet(double cubicfeet)
         {
-            double value = (double) cubicfeet;
-            return new Volume(value, VolumeUnit.CubicFoot);
+            return new Volume(cubicfeet, VolumeUnit.CubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicHectometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicHectometers(QuantityValue cubichectometers)
+        public static Volume FromCubicHectometers(double cubichectometers)
         {
-            double value = (double) cubichectometers;
-            return new Volume(value, VolumeUnit.CubicHectometer);
+            return new Volume(cubichectometers, VolumeUnit.CubicHectometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicInches(QuantityValue cubicinches)
+        public static Volume FromCubicInches(double cubicinches)
         {
-            double value = (double) cubicinches;
-            return new Volume(value, VolumeUnit.CubicInch);
+            return new Volume(cubicinches, VolumeUnit.CubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicKilometers(QuantityValue cubickilometers)
+        public static Volume FromCubicKilometers(double cubickilometers)
         {
-            double value = (double) cubickilometers;
-            return new Volume(value, VolumeUnit.CubicKilometer);
+            return new Volume(cubickilometers, VolumeUnit.CubicKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMeters(QuantityValue cubicmeters)
+        public static Volume FromCubicMeters(double cubicmeters)
         {
-            double value = (double) cubicmeters;
-            return new Volume(value, VolumeUnit.CubicMeter);
+            return new Volume(cubicmeters, VolumeUnit.CubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMicrometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMicrometers(QuantityValue cubicmicrometers)
+        public static Volume FromCubicMicrometers(double cubicmicrometers)
         {
-            double value = (double) cubicmicrometers;
-            return new Volume(value, VolumeUnit.CubicMicrometer);
+            return new Volume(cubicmicrometers, VolumeUnit.CubicMicrometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMiles(QuantityValue cubicmiles)
+        public static Volume FromCubicMiles(double cubicmiles)
         {
-            double value = (double) cubicmiles;
-            return new Volume(value, VolumeUnit.CubicMile);
+            return new Volume(cubicmiles, VolumeUnit.CubicMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMillimeters(QuantityValue cubicmillimeters)
+        public static Volume FromCubicMillimeters(double cubicmillimeters)
         {
-            double value = (double) cubicmillimeters;
-            return new Volume(value, VolumeUnit.CubicMillimeter);
+            return new Volume(cubicmillimeters, VolumeUnit.CubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicYards(QuantityValue cubicyards)
+        public static Volume FromCubicYards(double cubicyards)
         {
-            double value = (double) cubicyards;
-            return new Volume(value, VolumeUnit.CubicYard);
+            return new Volume(cubicyards, VolumeUnit.CubicYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Decaliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDecaliters(QuantityValue decaliters)
+        public static Volume FromDecaliters(double decaliters)
         {
-            double value = (double) decaliters;
-            return new Volume(value, VolumeUnit.Decaliter);
+            return new Volume(decaliters, VolumeUnit.Decaliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.DecausGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDecausGallons(QuantityValue decausgallons)
+        public static Volume FromDecausGallons(double decausgallons)
         {
-            double value = (double) decausgallons;
-            return new Volume(value, VolumeUnit.DecausGallon);
+            return new Volume(decausgallons, VolumeUnit.DecausGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Deciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDeciliters(QuantityValue deciliters)
+        public static Volume FromDeciliters(double deciliters)
         {
-            double value = (double) deciliters;
-            return new Volume(value, VolumeUnit.Deciliter);
+            return new Volume(deciliters, VolumeUnit.Deciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.DeciusGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDeciusGallons(QuantityValue deciusgallons)
+        public static Volume FromDeciusGallons(double deciusgallons)
         {
-            double value = (double) deciusgallons;
-            return new Volume(value, VolumeUnit.DeciusGallon);
+            return new Volume(deciusgallons, VolumeUnit.DeciusGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectocubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectocubicFeet(QuantityValue hectocubicfeet)
+        public static Volume FromHectocubicFeet(double hectocubicfeet)
         {
-            double value = (double) hectocubicfeet;
-            return new Volume(value, VolumeUnit.HectocubicFoot);
+            return new Volume(hectocubicfeet, VolumeUnit.HectocubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectocubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectocubicMeters(QuantityValue hectocubicmeters)
+        public static Volume FromHectocubicMeters(double hectocubicmeters)
         {
-            double value = (double) hectocubicmeters;
-            return new Volume(value, VolumeUnit.HectocubicMeter);
+            return new Volume(hectocubicmeters, VolumeUnit.HectocubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Hectoliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectoliters(QuantityValue hectoliters)
+        public static Volume FromHectoliters(double hectoliters)
         {
-            double value = (double) hectoliters;
-            return new Volume(value, VolumeUnit.Hectoliter);
+            return new Volume(hectoliters, VolumeUnit.Hectoliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectousGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectousGallons(QuantityValue hectousgallons)
+        public static Volume FromHectousGallons(double hectousgallons)
         {
-            double value = (double) hectousgallons;
-            return new Volume(value, VolumeUnit.HectousGallon);
+            return new Volume(hectousgallons, VolumeUnit.HectousGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialBeerBarrel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialBeerBarrels(QuantityValue imperialbeerbarrels)
+        public static Volume FromImperialBeerBarrels(double imperialbeerbarrels)
         {
-            double value = (double) imperialbeerbarrels;
-            return new Volume(value, VolumeUnit.ImperialBeerBarrel);
+            return new Volume(imperialbeerbarrels, VolumeUnit.ImperialBeerBarrel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialGallons(QuantityValue imperialgallons)
+        public static Volume FromImperialGallons(double imperialgallons)
         {
-            double value = (double) imperialgallons;
-            return new Volume(value, VolumeUnit.ImperialGallon);
+            return new Volume(imperialgallons, VolumeUnit.ImperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialOunce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialOunces(QuantityValue imperialounces)
+        public static Volume FromImperialOunces(double imperialounces)
         {
-            double value = (double) imperialounces;
-            return new Volume(value, VolumeUnit.ImperialOunce);
+            return new Volume(imperialounces, VolumeUnit.ImperialOunce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialPint"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialPints(QuantityValue imperialpints)
+        public static Volume FromImperialPints(double imperialpints)
         {
-            double value = (double) imperialpints;
-            return new Volume(value, VolumeUnit.ImperialPint);
+            return new Volume(imperialpints, VolumeUnit.ImperialPint);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialQuart"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialQuarts(QuantityValue imperialquarts)
+        public static Volume FromImperialQuarts(double imperialquarts)
         {
-            double value = (double) imperialquarts;
-            return new Volume(value, VolumeUnit.ImperialQuart);
+            return new Volume(imperialquarts, VolumeUnit.ImperialQuart);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilocubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilocubicFeet(QuantityValue kilocubicfeet)
+        public static Volume FromKilocubicFeet(double kilocubicfeet)
         {
-            double value = (double) kilocubicfeet;
-            return new Volume(value, VolumeUnit.KilocubicFoot);
+            return new Volume(kilocubicfeet, VolumeUnit.KilocubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilocubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilocubicMeters(QuantityValue kilocubicmeters)
+        public static Volume FromKilocubicMeters(double kilocubicmeters)
         {
-            double value = (double) kilocubicmeters;
-            return new Volume(value, VolumeUnit.KilocubicMeter);
+            return new Volume(kilocubicmeters, VolumeUnit.KilocubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KiloimperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKiloimperialGallons(QuantityValue kiloimperialgallons)
+        public static Volume FromKiloimperialGallons(double kiloimperialgallons)
         {
-            double value = (double) kiloimperialgallons;
-            return new Volume(value, VolumeUnit.KiloimperialGallon);
+            return new Volume(kiloimperialgallons, VolumeUnit.KiloimperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Kiloliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKiloliters(QuantityValue kiloliters)
+        public static Volume FromKiloliters(double kiloliters)
         {
-            double value = (double) kiloliters;
-            return new Volume(value, VolumeUnit.Kiloliter);
+            return new Volume(kiloliters, VolumeUnit.Kiloliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilousGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilousGallons(QuantityValue kilousgallons)
+        public static Volume FromKilousGallons(double kilousgallons)
         {
-            double value = (double) kilousgallons;
-            return new Volume(value, VolumeUnit.KilousGallon);
+            return new Volume(kilousgallons, VolumeUnit.KilousGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Liter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromLiters(QuantityValue liters)
+        public static Volume FromLiters(double liters)
         {
-            double value = (double) liters;
-            return new Volume(value, VolumeUnit.Liter);
+            return new Volume(liters, VolumeUnit.Liter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegacubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegacubicFeet(QuantityValue megacubicfeet)
+        public static Volume FromMegacubicFeet(double megacubicfeet)
         {
-            double value = (double) megacubicfeet;
-            return new Volume(value, VolumeUnit.MegacubicFoot);
+            return new Volume(megacubicfeet, VolumeUnit.MegacubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegaimperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegaimperialGallons(QuantityValue megaimperialgallons)
+        public static Volume FromMegaimperialGallons(double megaimperialgallons)
         {
-            double value = (double) megaimperialgallons;
-            return new Volume(value, VolumeUnit.MegaimperialGallon);
+            return new Volume(megaimperialgallons, VolumeUnit.MegaimperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Megaliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegaliters(QuantityValue megaliters)
+        public static Volume FromMegaliters(double megaliters)
         {
-            double value = (double) megaliters;
-            return new Volume(value, VolumeUnit.Megaliter);
+            return new Volume(megaliters, VolumeUnit.Megaliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegausGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegausGallons(QuantityValue megausgallons)
+        public static Volume FromMegausGallons(double megausgallons)
         {
-            double value = (double) megausgallons;
-            return new Volume(value, VolumeUnit.MegausGallon);
+            return new Volume(megausgallons, VolumeUnit.MegausGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricCup"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMetricCups(QuantityValue metriccups)
+        public static Volume FromMetricCups(double metriccups)
         {
-            double value = (double) metriccups;
-            return new Volume(value, VolumeUnit.MetricCup);
+            return new Volume(metriccups, VolumeUnit.MetricCup);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricTeaspoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMetricTeaspoons(QuantityValue metricteaspoons)
+        public static Volume FromMetricTeaspoons(double metricteaspoons)
         {
-            double value = (double) metricteaspoons;
-            return new Volume(value, VolumeUnit.MetricTeaspoon);
+            return new Volume(metricteaspoons, VolumeUnit.MetricTeaspoon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Microliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMicroliters(QuantityValue microliters)
+        public static Volume FromMicroliters(double microliters)
         {
-            double value = (double) microliters;
-            return new Volume(value, VolumeUnit.Microliter);
+            return new Volume(microliters, VolumeUnit.Microliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Milliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMilliliters(QuantityValue milliliters)
+        public static Volume FromMilliliters(double milliliters)
         {
-            double value = (double) milliliters;
-            return new Volume(value, VolumeUnit.Milliliter);
+            return new Volume(milliliters, VolumeUnit.Milliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Nanoliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromNanoliters(QuantityValue nanoliters)
+        public static Volume FromNanoliters(double nanoliters)
         {
-            double value = (double) nanoliters;
-            return new Volume(value, VolumeUnit.Nanoliter);
+            return new Volume(nanoliters, VolumeUnit.Nanoliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.OilBarrel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromOilBarrels(QuantityValue oilbarrels)
+        public static Volume FromOilBarrels(double oilbarrels)
         {
-            double value = (double) oilbarrels;
-            return new Volume(value, VolumeUnit.OilBarrel);
+            return new Volume(oilbarrels, VolumeUnit.OilBarrel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UkTablespoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUkTablespoons(QuantityValue uktablespoons)
+        public static Volume FromUkTablespoons(double uktablespoons)
         {
-            double value = (double) uktablespoons;
-            return new Volume(value, VolumeUnit.UkTablespoon);
+            return new Volume(uktablespoons, VolumeUnit.UkTablespoon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsBeerBarrel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsBeerBarrels(QuantityValue usbeerbarrels)
+        public static Volume FromUsBeerBarrels(double usbeerbarrels)
         {
-            double value = (double) usbeerbarrels;
-            return new Volume(value, VolumeUnit.UsBeerBarrel);
+            return new Volume(usbeerbarrels, VolumeUnit.UsBeerBarrel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsCustomaryCup"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsCustomaryCups(QuantityValue uscustomarycups)
+        public static Volume FromUsCustomaryCups(double uscustomarycups)
         {
-            double value = (double) uscustomarycups;
-            return new Volume(value, VolumeUnit.UsCustomaryCup);
+            return new Volume(uscustomarycups, VolumeUnit.UsCustomaryCup);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsGallons(QuantityValue usgallons)
+        public static Volume FromUsGallons(double usgallons)
         {
-            double value = (double) usgallons;
-            return new Volume(value, VolumeUnit.UsGallon);
+            return new Volume(usgallons, VolumeUnit.UsGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsLegalCup"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsLegalCups(QuantityValue uslegalcups)
+        public static Volume FromUsLegalCups(double uslegalcups)
         {
-            double value = (double) uslegalcups;
-            return new Volume(value, VolumeUnit.UsLegalCup);
+            return new Volume(uslegalcups, VolumeUnit.UsLegalCup);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsOunce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsOunces(QuantityValue usounces)
+        public static Volume FromUsOunces(double usounces)
         {
-            double value = (double) usounces;
-            return new Volume(value, VolumeUnit.UsOunce);
+            return new Volume(usounces, VolumeUnit.UsOunce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsPint"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsPints(QuantityValue uspints)
+        public static Volume FromUsPints(double uspints)
         {
-            double value = (double) uspints;
-            return new Volume(value, VolumeUnit.UsPint);
+            return new Volume(uspints, VolumeUnit.UsPint);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsQuart"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsQuarts(QuantityValue usquarts)
+        public static Volume FromUsQuarts(double usquarts)
         {
-            double value = (double) usquarts;
-            return new Volume(value, VolumeUnit.UsQuart);
+            return new Volume(usquarts, VolumeUnit.UsQuart);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsTablespoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsTablespoons(QuantityValue ustablespoons)
+        public static Volume FromUsTablespoons(double ustablespoons)
         {
-            double value = (double) ustablespoons;
-            return new Volume(value, VolumeUnit.UsTablespoon);
+            return new Volume(ustablespoons, VolumeUnit.UsTablespoon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsTeaspoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsTeaspoons(QuantityValue usteaspoons)
+        public static Volume FromUsTeaspoons(double usteaspoons)
         {
-            double value = (double) usteaspoons;
-            return new Volume(value, VolumeUnit.UsTeaspoon);
+            return new Volume(usteaspoons, VolumeUnit.UsTeaspoon);
         }
 
         /// <summary>
@@ -1199,9 +1145,9 @@ public static Volume FromUsTeaspoons(QuantityValue usteaspoons)
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>Volume unit value.</returns>
-        public static Volume From(QuantityValue value, VolumeUnit fromUnit)
+        public static Volume From(double value, VolumeUnit fromUnit)
         {
-            return new Volume((double)value, fromUnit);
+            return new Volume(value, fromUnit);
         }
 
         #endregion
@@ -1658,15 +1604,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is VolumeUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is VolumeUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeUnit)} is supported.", nameof(unit));
@@ -1887,18 +1824,6 @@ public Volume ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumeUnit> IQuantity<VolumeUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not VolumeUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
index 93895cf334..af7057eac6 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
@@ -43,7 +43,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct VolumeConcentration :
-        IArithmeticQuantity<VolumeConcentration, VolumeConcentrationUnit, double>,
+        IArithmeticQuantity<VolumeConcentration, VolumeConcentrationUnit>,
 #if NET7_0_OR_GREATER
         IMultiplyOperators<VolumeConcentration, Density, MassConcentration>,
         IMultiplyOperators<VolumeConcentration, Molarity, Molarity>,
@@ -176,7 +176,7 @@ public VolumeConcentration(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -383,200 +383,180 @@ public static string GetAbbreviation(VolumeConcentrationUnit unit, IFormatProvid
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.CentilitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromCentilitersPerLiter(QuantityValue centilitersperliter)
+        public static VolumeConcentration FromCentilitersPerLiter(double centilitersperliter)
         {
-            double value = (double) centilitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerLiter);
+            return new VolumeConcentration(centilitersperliter, VolumeConcentrationUnit.CentilitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.CentilitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromCentilitersPerMililiter(QuantityValue centiliterspermililiter)
+        public static VolumeConcentration FromCentilitersPerMililiter(double centiliterspermililiter)
         {
-            double value = (double) centiliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMililiter);
+            return new VolumeConcentration(centiliterspermililiter, VolumeConcentrationUnit.CentilitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DecilitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecilitersPerLiter(QuantityValue decilitersperliter)
+        public static VolumeConcentration FromDecilitersPerLiter(double decilitersperliter)
         {
-            double value = (double) decilitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerLiter);
+            return new VolumeConcentration(decilitersperliter, VolumeConcentrationUnit.DecilitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DecilitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecilitersPerMililiter(QuantityValue deciliterspermililiter)
+        public static VolumeConcentration FromDecilitersPerMililiter(double deciliterspermililiter)
         {
-            double value = (double) deciliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMililiter);
+            return new VolumeConcentration(deciliterspermililiter, VolumeConcentrationUnit.DecilitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DecimalFraction"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecimalFractions(QuantityValue decimalfractions)
+        public static VolumeConcentration FromDecimalFractions(double decimalfractions)
         {
-            double value = (double) decimalfractions;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.DecimalFraction);
+            return new VolumeConcentration(decimalfractions, VolumeConcentrationUnit.DecimalFraction);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.LitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromLitersPerLiter(QuantityValue litersperliter)
+        public static VolumeConcentration FromLitersPerLiter(double litersperliter)
         {
-            double value = (double) litersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerLiter);
+            return new VolumeConcentration(litersperliter, VolumeConcentrationUnit.LitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.LitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromLitersPerMililiter(QuantityValue literspermililiter)
+        public static VolumeConcentration FromLitersPerMililiter(double literspermililiter)
         {
-            double value = (double) literspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMililiter);
+            return new VolumeConcentration(literspermililiter, VolumeConcentrationUnit.LitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MicrolitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMicrolitersPerLiter(QuantityValue microlitersperliter)
+        public static VolumeConcentration FromMicrolitersPerLiter(double microlitersperliter)
         {
-            double value = (double) microlitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerLiter);
+            return new VolumeConcentration(microlitersperliter, VolumeConcentrationUnit.MicrolitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MicrolitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMicrolitersPerMililiter(QuantityValue microliterspermililiter)
+        public static VolumeConcentration FromMicrolitersPerMililiter(double microliterspermililiter)
         {
-            double value = (double) microliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMililiter);
+            return new VolumeConcentration(microliterspermililiter, VolumeConcentrationUnit.MicrolitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MillilitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMillilitersPerLiter(QuantityValue millilitersperliter)
+        public static VolumeConcentration FromMillilitersPerLiter(double millilitersperliter)
         {
-            double value = (double) millilitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerLiter);
+            return new VolumeConcentration(millilitersperliter, VolumeConcentrationUnit.MillilitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MillilitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMillilitersPerMililiter(QuantityValue milliliterspermililiter)
+        public static VolumeConcentration FromMillilitersPerMililiter(double milliliterspermililiter)
         {
-            double value = (double) milliliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMililiter);
+            return new VolumeConcentration(milliliterspermililiter, VolumeConcentrationUnit.MillilitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.NanolitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromNanolitersPerLiter(QuantityValue nanolitersperliter)
+        public static VolumeConcentration FromNanolitersPerLiter(double nanolitersperliter)
         {
-            double value = (double) nanolitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerLiter);
+            return new VolumeConcentration(nanolitersperliter, VolumeConcentrationUnit.NanolitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.NanolitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromNanolitersPerMililiter(QuantityValue nanoliterspermililiter)
+        public static VolumeConcentration FromNanolitersPerMililiter(double nanoliterspermililiter)
         {
-            double value = (double) nanoliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMililiter);
+            return new VolumeConcentration(nanoliterspermililiter, VolumeConcentrationUnit.NanolitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerBillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerBillion(QuantityValue partsperbillion)
+        public static VolumeConcentration FromPartsPerBillion(double partsperbillion)
         {
-            double value = (double) partsperbillion;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerBillion);
+            return new VolumeConcentration(partsperbillion, VolumeConcentrationUnit.PartPerBillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerMillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerMillion(QuantityValue partspermillion)
+        public static VolumeConcentration FromPartsPerMillion(double partspermillion)
         {
-            double value = (double) partspermillion;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerMillion);
+            return new VolumeConcentration(partspermillion, VolumeConcentrationUnit.PartPerMillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerThousand"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerThousand(QuantityValue partsperthousand)
+        public static VolumeConcentration FromPartsPerThousand(double partsperthousand)
         {
-            double value = (double) partsperthousand;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerThousand);
+            return new VolumeConcentration(partsperthousand, VolumeConcentrationUnit.PartPerThousand);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerTrillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerTrillion(QuantityValue partspertrillion)
+        public static VolumeConcentration FromPartsPerTrillion(double partspertrillion)
         {
-            double value = (double) partspertrillion;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerTrillion);
+            return new VolumeConcentration(partspertrillion, VolumeConcentrationUnit.PartPerTrillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.Percent"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPercent(QuantityValue percent)
+        public static VolumeConcentration FromPercent(double percent)
         {
-            double value = (double) percent;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.Percent);
+            return new VolumeConcentration(percent, VolumeConcentrationUnit.Percent);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PicolitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPicolitersPerLiter(QuantityValue picolitersperliter)
+        public static VolumeConcentration FromPicolitersPerLiter(double picolitersperliter)
         {
-            double value = (double) picolitersperliter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerLiter);
+            return new VolumeConcentration(picolitersperliter, VolumeConcentrationUnit.PicolitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PicolitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPicolitersPerMililiter(QuantityValue picoliterspermililiter)
+        public static VolumeConcentration FromPicolitersPerMililiter(double picoliterspermililiter)
         {
-            double value = (double) picoliterspermililiter;
-            return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMililiter);
+            return new VolumeConcentration(picoliterspermililiter, VolumeConcentrationUnit.PicolitersPerMililiter);
         }
 
         /// <summary>
@@ -585,9 +565,9 @@ public static VolumeConcentration FromPicolitersPerMililiter(QuantityValue picol
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumeConcentration unit value.</returns>
-        public static VolumeConcentration From(QuantityValue value, VolumeConcentrationUnit fromUnit)
+        public static VolumeConcentration From(double value, VolumeConcentrationUnit fromUnit)
         {
-            return new VolumeConcentration((double)value, fromUnit);
+            return new VolumeConcentration(value, fromUnit);
         }
 
         #endregion
@@ -1014,15 +994,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is VolumeConcentrationUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeConcentrationUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is VolumeConcentrationUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeConcentrationUnit)} is supported.", nameof(unit));
@@ -1175,18 +1146,6 @@ public VolumeConcentration ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumeConcentrationUnit> IQuantity<VolumeConcentrationUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not VolumeConcentrationUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeConcentrationUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
index a76a9f150a..9431de6549 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct VolumeFlow :
-        IArithmeticQuantity<VolumeFlow, VolumeFlowUnit, double>,
+        IArithmeticQuantity<VolumeFlow, VolumeFlowUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<VolumeFlow, Speed, Area>,
         IMultiplyOperators<VolumeFlow, Density, MassFlow>,
@@ -223,7 +223,7 @@ public VolumeFlow(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -759,670 +759,603 @@ public static string GetAbbreviation(VolumeFlowUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerDay(QuantityValue acrefeetperday)
+        public static VolumeFlow FromAcreFeetPerDay(double acrefeetperday)
         {
-            double value = (double) acrefeetperday;
-            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerDay);
+            return new VolumeFlow(acrefeetperday, VolumeFlowUnit.AcreFootPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerHour(QuantityValue acrefeetperhour)
+        public static VolumeFlow FromAcreFeetPerHour(double acrefeetperhour)
         {
-            double value = (double) acrefeetperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerHour);
+            return new VolumeFlow(acrefeetperhour, VolumeFlowUnit.AcreFootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerMinute(QuantityValue acrefeetperminute)
+        public static VolumeFlow FromAcreFeetPerMinute(double acrefeetperminute)
         {
-            double value = (double) acrefeetperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerMinute);
+            return new VolumeFlow(acrefeetperminute, VolumeFlowUnit.AcreFootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerSecond(QuantityValue acrefeetpersecond)
+        public static VolumeFlow FromAcreFeetPerSecond(double acrefeetpersecond)
         {
-            double value = (double) acrefeetpersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerSecond);
+            return new VolumeFlow(acrefeetpersecond, VolumeFlowUnit.AcreFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerDay(QuantityValue centilitersperday)
+        public static VolumeFlow FromCentilitersPerDay(double centilitersperday)
         {
-            double value = (double) centilitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerDay);
+            return new VolumeFlow(centilitersperday, VolumeFlowUnit.CentiliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerHour(QuantityValue centilitersperhour)
+        public static VolumeFlow FromCentilitersPerHour(double centilitersperhour)
         {
-            double value = (double) centilitersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerHour);
+            return new VolumeFlow(centilitersperhour, VolumeFlowUnit.CentiliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerMinute(QuantityValue centilitersperminute)
+        public static VolumeFlow FromCentilitersPerMinute(double centilitersperminute)
         {
-            double value = (double) centilitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerMinute);
+            return new VolumeFlow(centilitersperminute, VolumeFlowUnit.CentiliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerSecond(QuantityValue centiliterspersecond)
+        public static VolumeFlow FromCentilitersPerSecond(double centiliterspersecond)
         {
-            double value = (double) centiliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerSecond);
+            return new VolumeFlow(centiliterspersecond, VolumeFlowUnit.CentiliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicCentimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicCentimetersPerMinute(QuantityValue cubiccentimetersperminute)
+        public static VolumeFlow FromCubicCentimetersPerMinute(double cubiccentimetersperminute)
         {
-            double value = (double) cubiccentimetersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicCentimeterPerMinute);
+            return new VolumeFlow(cubiccentimetersperminute, VolumeFlowUnit.CubicCentimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicDecimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicDecimetersPerMinute(QuantityValue cubicdecimetersperminute)
+        public static VolumeFlow FromCubicDecimetersPerMinute(double cubicdecimetersperminute)
         {
-            double value = (double) cubicdecimetersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicDecimeterPerMinute);
+            return new VolumeFlow(cubicdecimetersperminute, VolumeFlowUnit.CubicDecimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerHour(QuantityValue cubicfeetperhour)
+        public static VolumeFlow FromCubicFeetPerHour(double cubicfeetperhour)
         {
-            double value = (double) cubicfeetperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerHour);
+            return new VolumeFlow(cubicfeetperhour, VolumeFlowUnit.CubicFootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerMinute(QuantityValue cubicfeetperminute)
+        public static VolumeFlow FromCubicFeetPerMinute(double cubicfeetperminute)
         {
-            double value = (double) cubicfeetperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerMinute);
+            return new VolumeFlow(cubicfeetperminute, VolumeFlowUnit.CubicFootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerSecond(QuantityValue cubicfeetpersecond)
+        public static VolumeFlow FromCubicFeetPerSecond(double cubicfeetpersecond)
         {
-            double value = (double) cubicfeetpersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerSecond);
+            return new VolumeFlow(cubicfeetpersecond, VolumeFlowUnit.CubicFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerDay(QuantityValue cubicmetersperday)
+        public static VolumeFlow FromCubicMetersPerDay(double cubicmetersperday)
         {
-            double value = (double) cubicmetersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerDay);
+            return new VolumeFlow(cubicmetersperday, VolumeFlowUnit.CubicMeterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerHour(QuantityValue cubicmetersperhour)
+        public static VolumeFlow FromCubicMetersPerHour(double cubicmetersperhour)
         {
-            double value = (double) cubicmetersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerHour);
+            return new VolumeFlow(cubicmetersperhour, VolumeFlowUnit.CubicMeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerMinute(QuantityValue cubicmetersperminute)
+        public static VolumeFlow FromCubicMetersPerMinute(double cubicmetersperminute)
         {
-            double value = (double) cubicmetersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerMinute);
+            return new VolumeFlow(cubicmetersperminute, VolumeFlowUnit.CubicMeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerSecond(QuantityValue cubicmeterspersecond)
+        public static VolumeFlow FromCubicMetersPerSecond(double cubicmeterspersecond)
         {
-            double value = (double) cubicmeterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerSecond);
+            return new VolumeFlow(cubicmeterspersecond, VolumeFlowUnit.CubicMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMillimeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMillimetersPerSecond(QuantityValue cubicmillimeterspersecond)
+        public static VolumeFlow FromCubicMillimetersPerSecond(double cubicmillimeterspersecond)
         {
-            double value = (double) cubicmillimeterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerSecond);
+            return new VolumeFlow(cubicmillimeterspersecond, VolumeFlowUnit.CubicMillimeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerDay(QuantityValue cubicyardsperday)
+        public static VolumeFlow FromCubicYardsPerDay(double cubicyardsperday)
         {
-            double value = (double) cubicyardsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerDay);
+            return new VolumeFlow(cubicyardsperday, VolumeFlowUnit.CubicYardPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerHour(QuantityValue cubicyardsperhour)
+        public static VolumeFlow FromCubicYardsPerHour(double cubicyardsperhour)
         {
-            double value = (double) cubicyardsperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerHour);
+            return new VolumeFlow(cubicyardsperhour, VolumeFlowUnit.CubicYardPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerMinute(QuantityValue cubicyardsperminute)
+        public static VolumeFlow FromCubicYardsPerMinute(double cubicyardsperminute)
         {
-            double value = (double) cubicyardsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerMinute);
+            return new VolumeFlow(cubicyardsperminute, VolumeFlowUnit.CubicYardPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerSecond(QuantityValue cubicyardspersecond)
+        public static VolumeFlow FromCubicYardsPerSecond(double cubicyardspersecond)
         {
-            double value = (double) cubicyardspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond);
+            return new VolumeFlow(cubicyardspersecond, VolumeFlowUnit.CubicYardPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerDay(QuantityValue decilitersperday)
+        public static VolumeFlow FromDecilitersPerDay(double decilitersperday)
         {
-            double value = (double) decilitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerDay);
+            return new VolumeFlow(decilitersperday, VolumeFlowUnit.DeciliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerHour(QuantityValue decilitersperhour)
+        public static VolumeFlow FromDecilitersPerHour(double decilitersperhour)
         {
-            double value = (double) decilitersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerHour);
+            return new VolumeFlow(decilitersperhour, VolumeFlowUnit.DeciliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerMinute(QuantityValue decilitersperminute)
+        public static VolumeFlow FromDecilitersPerMinute(double decilitersperminute)
         {
-            double value = (double) decilitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerMinute);
+            return new VolumeFlow(decilitersperminute, VolumeFlowUnit.DeciliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerSecond(QuantityValue deciliterspersecond)
+        public static VolumeFlow FromDecilitersPerSecond(double deciliterspersecond)
         {
-            double value = (double) deciliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond);
+            return new VolumeFlow(deciliterspersecond, VolumeFlowUnit.DeciliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerDay(QuantityValue kilolitersperday)
+        public static VolumeFlow FromKilolitersPerDay(double kilolitersperday)
         {
-            double value = (double) kilolitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerDay);
+            return new VolumeFlow(kilolitersperday, VolumeFlowUnit.KiloliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerHour(QuantityValue kilolitersperhour)
+        public static VolumeFlow FromKilolitersPerHour(double kilolitersperhour)
         {
-            double value = (double) kilolitersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerHour);
+            return new VolumeFlow(kilolitersperhour, VolumeFlowUnit.KiloliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerMinute(QuantityValue kilolitersperminute)
+        public static VolumeFlow FromKilolitersPerMinute(double kilolitersperminute)
         {
-            double value = (double) kilolitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerMinute);
+            return new VolumeFlow(kilolitersperminute, VolumeFlowUnit.KiloliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerSecond(QuantityValue kiloliterspersecond)
+        public static VolumeFlow FromKilolitersPerSecond(double kiloliterspersecond)
         {
-            double value = (double) kiloliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerSecond);
+            return new VolumeFlow(kiloliterspersecond, VolumeFlowUnit.KiloliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KilousGallonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilousGallonsPerMinute(QuantityValue kilousgallonsperminute)
+        public static VolumeFlow FromKilousGallonsPerMinute(double kilousgallonsperminute)
         {
-            double value = (double) kilousgallonsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.KilousGallonPerMinute);
+            return new VolumeFlow(kilousgallonsperminute, VolumeFlowUnit.KilousGallonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerDay(QuantityValue litersperday)
+        public static VolumeFlow FromLitersPerDay(double litersperday)
         {
-            double value = (double) litersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.LiterPerDay);
+            return new VolumeFlow(litersperday, VolumeFlowUnit.LiterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerHour(QuantityValue litersperhour)
+        public static VolumeFlow FromLitersPerHour(double litersperhour)
         {
-            double value = (double) litersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.LiterPerHour);
+            return new VolumeFlow(litersperhour, VolumeFlowUnit.LiterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerMinute(QuantityValue litersperminute)
+        public static VolumeFlow FromLitersPerMinute(double litersperminute)
         {
-            double value = (double) litersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.LiterPerMinute);
+            return new VolumeFlow(litersperminute, VolumeFlowUnit.LiterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerSecond(QuantityValue literspersecond)
+        public static VolumeFlow FromLitersPerSecond(double literspersecond)
         {
-            double value = (double) literspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.LiterPerSecond);
+            return new VolumeFlow(literspersecond, VolumeFlowUnit.LiterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerDay(QuantityValue megalitersperday)
+        public static VolumeFlow FromMegalitersPerDay(double megalitersperday)
         {
-            double value = (double) megalitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerDay);
+            return new VolumeFlow(megalitersperday, VolumeFlowUnit.MegaliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerHour(QuantityValue megalitersperhour)
+        public static VolumeFlow FromMegalitersPerHour(double megalitersperhour)
         {
-            double value = (double) megalitersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerHour);
+            return new VolumeFlow(megalitersperhour, VolumeFlowUnit.MegaliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerMinute(QuantityValue megalitersperminute)
+        public static VolumeFlow FromMegalitersPerMinute(double megalitersperminute)
         {
-            double value = (double) megalitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerMinute);
+            return new VolumeFlow(megalitersperminute, VolumeFlowUnit.MegaliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerSecond(QuantityValue megaliterspersecond)
+        public static VolumeFlow FromMegalitersPerSecond(double megaliterspersecond)
         {
-            double value = (double) megaliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerSecond);
+            return new VolumeFlow(megaliterspersecond, VolumeFlowUnit.MegaliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaukGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegaukGallonsPerDay(QuantityValue megaukgallonsperday)
+        public static VolumeFlow FromMegaukGallonsPerDay(double megaukgallonsperday)
         {
-            double value = (double) megaukgallonsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerDay);
+            return new VolumeFlow(megaukgallonsperday, VolumeFlowUnit.MegaukGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaukGallonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegaukGallonsPerSecond(QuantityValue megaukgallonspersecond)
+        public static VolumeFlow FromMegaukGallonsPerSecond(double megaukgallonspersecond)
         {
-            double value = (double) megaukgallonspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerSecond);
+            return new VolumeFlow(megaukgallonspersecond, VolumeFlowUnit.MegaukGallonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegausGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegausGallonsPerDay(QuantityValue megausgallonsperday)
+        public static VolumeFlow FromMegausGallonsPerDay(double megausgallonsperday)
         {
-            double value = (double) megausgallonsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MegausGallonPerDay);
+            return new VolumeFlow(megausgallonsperday, VolumeFlowUnit.MegausGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerDay(QuantityValue microlitersperday)
+        public static VolumeFlow FromMicrolitersPerDay(double microlitersperday)
         {
-            double value = (double) microlitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerDay);
+            return new VolumeFlow(microlitersperday, VolumeFlowUnit.MicroliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerHour(QuantityValue microlitersperhour)
+        public static VolumeFlow FromMicrolitersPerHour(double microlitersperhour)
         {
-            double value = (double) microlitersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerHour);
+            return new VolumeFlow(microlitersperhour, VolumeFlowUnit.MicroliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerMinute(QuantityValue microlitersperminute)
+        public static VolumeFlow FromMicrolitersPerMinute(double microlitersperminute)
         {
-            double value = (double) microlitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerMinute);
+            return new VolumeFlow(microlitersperminute, VolumeFlowUnit.MicroliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerSecond(QuantityValue microliterspersecond)
+        public static VolumeFlow FromMicrolitersPerSecond(double microliterspersecond)
         {
-            double value = (double) microliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerSecond);
+            return new VolumeFlow(microliterspersecond, VolumeFlowUnit.MicroliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerDay(QuantityValue millilitersperday)
+        public static VolumeFlow FromMillilitersPerDay(double millilitersperday)
         {
-            double value = (double) millilitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerDay);
+            return new VolumeFlow(millilitersperday, VolumeFlowUnit.MilliliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerHour(QuantityValue millilitersperhour)
+        public static VolumeFlow FromMillilitersPerHour(double millilitersperhour)
         {
-            double value = (double) millilitersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerHour);
+            return new VolumeFlow(millilitersperhour, VolumeFlowUnit.MilliliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerMinute(QuantityValue millilitersperminute)
+        public static VolumeFlow FromMillilitersPerMinute(double millilitersperminute)
         {
-            double value = (double) millilitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerMinute);
+            return new VolumeFlow(millilitersperminute, VolumeFlowUnit.MilliliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerSecond(QuantityValue milliliterspersecond)
+        public static VolumeFlow FromMillilitersPerSecond(double milliliterspersecond)
         {
-            double value = (double) milliliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerSecond);
+            return new VolumeFlow(milliliterspersecond, VolumeFlowUnit.MilliliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MillionUsGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillionUsGallonsPerDay(QuantityValue millionusgallonsperday)
+        public static VolumeFlow FromMillionUsGallonsPerDay(double millionusgallonsperday)
         {
-            double value = (double) millionusgallonsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.MillionUsGallonPerDay);
+            return new VolumeFlow(millionusgallonsperday, VolumeFlowUnit.MillionUsGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerDay(QuantityValue nanolitersperday)
+        public static VolumeFlow FromNanolitersPerDay(double nanolitersperday)
         {
-            double value = (double) nanolitersperday;
-            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerDay);
+            return new VolumeFlow(nanolitersperday, VolumeFlowUnit.NanoliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerHour(QuantityValue nanolitersperhour)
+        public static VolumeFlow FromNanolitersPerHour(double nanolitersperhour)
         {
-            double value = (double) nanolitersperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerHour);
+            return new VolumeFlow(nanolitersperhour, VolumeFlowUnit.NanoliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerMinute(QuantityValue nanolitersperminute)
+        public static VolumeFlow FromNanolitersPerMinute(double nanolitersperminute)
         {
-            double value = (double) nanolitersperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerMinute);
+            return new VolumeFlow(nanolitersperminute, VolumeFlowUnit.NanoliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerSecond(QuantityValue nanoliterspersecond)
+        public static VolumeFlow FromNanolitersPerSecond(double nanoliterspersecond)
         {
-            double value = (double) nanoliterspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerSecond);
+            return new VolumeFlow(nanoliterspersecond, VolumeFlowUnit.NanoliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerDay(QuantityValue oilbarrelsperday)
+        public static VolumeFlow FromOilBarrelsPerDay(double oilbarrelsperday)
         {
-            double value = (double) oilbarrelsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerDay);
+            return new VolumeFlow(oilbarrelsperday, VolumeFlowUnit.OilBarrelPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerHour(QuantityValue oilbarrelsperhour)
+        public static VolumeFlow FromOilBarrelsPerHour(double oilbarrelsperhour)
         {
-            double value = (double) oilbarrelsperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerHour);
+            return new VolumeFlow(oilbarrelsperhour, VolumeFlowUnit.OilBarrelPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerMinute(QuantityValue oilbarrelsperminute)
+        public static VolumeFlow FromOilBarrelsPerMinute(double oilbarrelsperminute)
         {
-            double value = (double) oilbarrelsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerMinute);
+            return new VolumeFlow(oilbarrelsperminute, VolumeFlowUnit.OilBarrelPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerSecond(QuantityValue oilbarrelspersecond)
+        public static VolumeFlow FromOilBarrelsPerSecond(double oilbarrelspersecond)
         {
-            double value = (double) oilbarrelspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerSecond);
+            return new VolumeFlow(oilbarrelspersecond, VolumeFlowUnit.OilBarrelPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerDay(QuantityValue ukgallonsperday)
+        public static VolumeFlow FromUkGallonsPerDay(double ukgallonsperday)
         {
-            double value = (double) ukgallonsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerDay);
+            return new VolumeFlow(ukgallonsperday, VolumeFlowUnit.UkGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerHour(QuantityValue ukgallonsperhour)
+        public static VolumeFlow FromUkGallonsPerHour(double ukgallonsperhour)
         {
-            double value = (double) ukgallonsperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerHour);
+            return new VolumeFlow(ukgallonsperhour, VolumeFlowUnit.UkGallonPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerMinute(QuantityValue ukgallonsperminute)
+        public static VolumeFlow FromUkGallonsPerMinute(double ukgallonsperminute)
         {
-            double value = (double) ukgallonsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerMinute);
+            return new VolumeFlow(ukgallonsperminute, VolumeFlowUnit.UkGallonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerSecond(QuantityValue ukgallonspersecond)
+        public static VolumeFlow FromUkGallonsPerSecond(double ukgallonspersecond)
         {
-            double value = (double) ukgallonspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerSecond);
+            return new VolumeFlow(ukgallonspersecond, VolumeFlowUnit.UkGallonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerDay(QuantityValue usgallonsperday)
+        public static VolumeFlow FromUsGallonsPerDay(double usgallonsperday)
         {
-            double value = (double) usgallonsperday;
-            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerDay);
+            return new VolumeFlow(usgallonsperday, VolumeFlowUnit.UsGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerHour(QuantityValue usgallonsperhour)
+        public static VolumeFlow FromUsGallonsPerHour(double usgallonsperhour)
         {
-            double value = (double) usgallonsperhour;
-            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerHour);
+            return new VolumeFlow(usgallonsperhour, VolumeFlowUnit.UsGallonPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerMinute(QuantityValue usgallonsperminute)
+        public static VolumeFlow FromUsGallonsPerMinute(double usgallonsperminute)
         {
-            double value = (double) usgallonsperminute;
-            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerMinute);
+            return new VolumeFlow(usgallonsperminute, VolumeFlowUnit.UsGallonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerSecond(QuantityValue usgallonspersecond)
+        public static VolumeFlow FromUsGallonsPerSecond(double usgallonspersecond)
         {
-            double value = (double) usgallonspersecond;
-            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerSecond);
+            return new VolumeFlow(usgallonspersecond, VolumeFlowUnit.UsGallonPerSecond);
         }
 
         /// <summary>
@@ -1431,9 +1364,9 @@ public static VolumeFlow FromUsGallonsPerSecond(QuantityValue usgallonspersecond
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumeFlow unit value.</returns>
-        public static VolumeFlow From(QuantityValue value, VolumeFlowUnit fromUnit)
+        public static VolumeFlow From(double value, VolumeFlowUnit fromUnit)
         {
-            return new VolumeFlow((double)value, fromUnit);
+            return new VolumeFlow(value, fromUnit);
         }
 
         #endregion
@@ -1884,15 +1817,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is VolumeFlowUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is VolumeFlowUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowUnit)} is supported.", nameof(unit));
@@ -2139,18 +2063,6 @@ public VolumeFlow ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumeFlowUnit> IQuantity<VolumeFlowUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not VolumeFlowUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
index 058ca287dd..1c902215c3 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct VolumeFlowPerArea :
-        IArithmeticQuantity<VolumeFlowPerArea, VolumeFlowPerAreaUnit, double>,
+        IArithmeticQuantity<VolumeFlowPerArea, VolumeFlowPerAreaUnit>,
         IComparable,
         IComparable<VolumeFlowPerArea>,
         IConvertible,
@@ -148,7 +148,7 @@ public VolumeFlowPerArea(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -229,20 +229,18 @@ public static string GetAbbreviation(VolumeFlowPerAreaUnit unit, IFormatProvider
         ///     Creates a <see cref="VolumeFlowPerArea"/> from <see cref="VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(QuantityValue cubicfeetperminutepersquarefoot)
+        public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(double cubicfeetperminutepersquarefoot)
         {
-            double value = (double) cubicfeetperminutepersquarefoot;
-            return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
+            return new VolumeFlowPerArea(cubicfeetperminutepersquarefoot, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlowPerArea"/> from <see cref="VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(QuantityValue cubicmeterspersecondpersquaremeter)
+        public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(double cubicmeterspersecondpersquaremeter)
         {
-            double value = (double) cubicmeterspersecondpersquaremeter;
-            return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
+            return new VolumeFlowPerArea(cubicmeterspersecondpersquaremeter, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
         }
 
         /// <summary>
@@ -251,9 +249,9 @@ public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(QuantityV
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumeFlowPerArea unit value.</returns>
-        public static VolumeFlowPerArea From(QuantityValue value, VolumeFlowPerAreaUnit fromUnit)
+        public static VolumeFlowPerArea From(double value, VolumeFlowPerAreaUnit fromUnit)
         {
-            return new VolumeFlowPerArea((double)value, fromUnit);
+            return new VolumeFlowPerArea(value, fromUnit);
         }
 
         #endregion
@@ -664,15 +662,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is VolumeFlowPerAreaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowPerAreaUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is VolumeFlowPerAreaUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowPerAreaUnit)} is supported.", nameof(unit));
@@ -789,18 +778,6 @@ public VolumeFlowPerArea ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumeFlowPerAreaUnit> IQuantity<VolumeFlowPerAreaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not VolumeFlowPerAreaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumeFlowPerAreaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
index a51dabcde1..dab420b6c8 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct VolumePerLength :
-        IArithmeticQuantity<VolumePerLength, VolumePerLengthUnit, double>,
+        IArithmeticQuantity<VolumePerLength, VolumePerLengthUnit>,
         IComparable,
         IComparable<VolumePerLength>,
         IConvertible,
@@ -155,7 +155,7 @@ public VolumePerLength(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -285,90 +285,81 @@ public static string GetAbbreviation(VolumePerLengthUnit unit, IFormatProvider?
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicMetersPerMeter(QuantityValue cubicmeterspermeter)
+        public static VolumePerLength FromCubicMetersPerMeter(double cubicmeterspermeter)
         {
-            double value = (double) cubicmeterspermeter;
-            return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter);
+            return new VolumePerLength(cubicmeterspermeter, VolumePerLengthUnit.CubicMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicYardPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicYardsPerFoot(QuantityValue cubicyardsperfoot)
+        public static VolumePerLength FromCubicYardsPerFoot(double cubicyardsperfoot)
         {
-            double value = (double) cubicyardsperfoot;
-            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot);
+            return new VolumePerLength(cubicyardsperfoot, VolumePerLengthUnit.CubicYardPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicYardPerUsSurveyFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(QuantityValue cubicyardsperussurveyfoot)
+        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double cubicyardsperussurveyfoot)
         {
-            double value = (double) cubicyardsperussurveyfoot;
-            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+            return new VolumePerLength(cubicyardsperussurveyfoot, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.ImperialGallonPerMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromImperialGallonsPerMile(QuantityValue imperialgallonspermile)
+        public static VolumePerLength FromImperialGallonsPerMile(double imperialgallonspermile)
         {
-            double value = (double) imperialgallonspermile;
-            return new VolumePerLength(value, VolumePerLengthUnit.ImperialGallonPerMile);
+            return new VolumePerLength(imperialgallonspermile, VolumePerLengthUnit.ImperialGallonPerMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerKilometer(QuantityValue litersperkilometer)
+        public static VolumePerLength FromLitersPerKilometer(double litersperkilometer)
         {
-            double value = (double) litersperkilometer;
-            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerKilometer);
+            return new VolumePerLength(litersperkilometer, VolumePerLengthUnit.LiterPerKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerMeter(QuantityValue literspermeter)
+        public static VolumePerLength FromLitersPerMeter(double literspermeter)
         {
-            double value = (double) literspermeter;
-            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMeter);
+            return new VolumePerLength(literspermeter, VolumePerLengthUnit.LiterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerMillimeter(QuantityValue literspermillimeter)
+        public static VolumePerLength FromLitersPerMillimeter(double literspermillimeter)
         {
-            double value = (double) literspermillimeter;
-            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMillimeter);
+            return new VolumePerLength(literspermillimeter, VolumePerLengthUnit.LiterPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.OilBarrelPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromOilBarrelsPerFoot(QuantityValue oilbarrelsperfoot)
+        public static VolumePerLength FromOilBarrelsPerFoot(double oilbarrelsperfoot)
         {
-            double value = (double) oilbarrelsperfoot;
-            return new VolumePerLength(value, VolumePerLengthUnit.OilBarrelPerFoot);
+            return new VolumePerLength(oilbarrelsperfoot, VolumePerLengthUnit.OilBarrelPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.UsGallonPerMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromUsGallonsPerMile(QuantityValue usgallonspermile)
+        public static VolumePerLength FromUsGallonsPerMile(double usgallonspermile)
         {
-            double value = (double) usgallonspermile;
-            return new VolumePerLength(value, VolumePerLengthUnit.UsGallonPerMile);
+            return new VolumePerLength(usgallonspermile, VolumePerLengthUnit.UsGallonPerMile);
         }
 
         /// <summary>
@@ -377,9 +368,9 @@ public static VolumePerLength FromUsGallonsPerMile(QuantityValue usgallonspermil
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumePerLength unit value.</returns>
-        public static VolumePerLength From(QuantityValue value, VolumePerLengthUnit fromUnit)
+        public static VolumePerLength From(double value, VolumePerLengthUnit fromUnit)
         {
-            return new VolumePerLength((double)value, fromUnit);
+            return new VolumePerLength(value, fromUnit);
         }
 
         #endregion
@@ -790,15 +781,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is VolumePerLengthUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumePerLengthUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is VolumePerLengthUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumePerLengthUnit)} is supported.", nameof(unit));
@@ -929,18 +911,6 @@ public VolumePerLength ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumePerLengthUnit> IQuantity<VolumePerLengthUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not VolumePerLengthUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumePerLengthUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
index 3e141d1649..ebd63a3c3b 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
@@ -40,7 +40,7 @@ namespace UnitsNet
     /// </remarks>
     [DataContract]
     public readonly partial struct VolumetricHeatCapacity :
-        IArithmeticQuantity<VolumetricHeatCapacity, VolumetricHeatCapacityUnit, double>,
+        IArithmeticQuantity<VolumetricHeatCapacity, VolumetricHeatCapacityUnit>,
         IComparable,
         IComparable<VolumetricHeatCapacity>,
         IConvertible,
@@ -158,7 +158,7 @@ public VolumetricHeatCapacity(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -288,90 +288,81 @@ public static string GetAbbreviation(VolumetricHeatCapacityUnit unit, IFormatPro
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(QuantityValue btuspercubicfootdegreefahrenheit)
+        public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(double btuspercubicfootdegreefahrenheit)
         {
-            double value = (double) btuspercubicfootdegreefahrenheit;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
+            return new VolumetricHeatCapacity(btuspercubicfootdegreefahrenheit, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius(QuantityValue caloriespercubiccentimeterdegreecelsius)
+        public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius(double caloriespercubiccentimeterdegreecelsius)
         {
-            double value = (double) caloriespercubiccentimeterdegreecelsius;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
+            return new VolumetricHeatCapacity(caloriespercubiccentimeterdegreecelsius, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(QuantityValue joulespercubicmeterdegreecelsius)
+        public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(double joulespercubicmeterdegreecelsius)
         {
-            double value = (double) joulespercubicmeterdegreecelsius;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
+            return new VolumetricHeatCapacity(joulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(QuantityValue joulespercubicmeterkelvin)
+        public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(double joulespercubicmeterkelvin)
         {
-            double value = (double) joulespercubicmeterkelvin;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
+            return new VolumetricHeatCapacity(joulespercubicmeterkelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCelsius(QuantityValue kilocaloriespercubiccentimeterdegreecelsius)
+        public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCelsius(double kilocaloriespercubiccentimeterdegreecelsius)
         {
-            double value = (double) kilocaloriespercubiccentimeterdegreecelsius;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
+            return new VolumetricHeatCapacity(kilocaloriespercubiccentimeterdegreecelsius, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(QuantityValue kilojoulespercubicmeterdegreecelsius)
+        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(double kilojoulespercubicmeterdegreecelsius)
         {
-            double value = (double) kilojoulespercubicmeterdegreecelsius;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
+            return new VolumetricHeatCapacity(kilojoulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(QuantityValue kilojoulespercubicmeterkelvin)
+        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(double kilojoulespercubicmeterkelvin)
         {
-            double value = (double) kilojoulespercubicmeterkelvin;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
+            return new VolumetricHeatCapacity(kilojoulespercubicmeterkelvin, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(QuantityValue megajoulespercubicmeterdegreecelsius)
+        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(double megajoulespercubicmeterdegreecelsius)
         {
-            double value = (double) megajoulespercubicmeterdegreecelsius;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
+            return new VolumetricHeatCapacity(megajoulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(QuantityValue megajoulespercubicmeterkelvin)
+        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(double megajoulespercubicmeterkelvin)
         {
-            double value = (double) megajoulespercubicmeterkelvin;
-            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
+            return new VolumetricHeatCapacity(megajoulespercubicmeterkelvin, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
         }
 
         /// <summary>
@@ -380,9 +371,9 @@ public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(QuantityV
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>VolumetricHeatCapacity unit value.</returns>
-        public static VolumetricHeatCapacity From(QuantityValue value, VolumetricHeatCapacityUnit fromUnit)
+        public static VolumetricHeatCapacity From(double value, VolumetricHeatCapacityUnit fromUnit)
         {
-            return new VolumetricHeatCapacity((double)value, fromUnit);
+            return new VolumetricHeatCapacity(value, fromUnit);
         }
 
         #endregion
@@ -793,15 +784,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is VolumetricHeatCapacityUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumetricHeatCapacityUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is VolumetricHeatCapacityUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumetricHeatCapacityUnit)} is supported.", nameof(unit));
@@ -932,18 +914,6 @@ public VolumetricHeatCapacity ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<VolumetricHeatCapacityUnit> IQuantity<VolumetricHeatCapacityUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not VolumetricHeatCapacityUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(VolumetricHeatCapacityUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
index 42412a843b..cad17c0388 100644
--- a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
@@ -37,7 +37,7 @@ namespace UnitsNet
     /// </summary>
     [DataContract]
     public readonly partial struct WarpingMomentOfInertia :
-        IArithmeticQuantity<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit, double>,
+        IArithmeticQuantity<WarpingMomentOfInertia, WarpingMomentOfInertiaUnit>,
         IComparable,
         IComparable<WarpingMomentOfInertia>,
         IConvertible,
@@ -152,7 +152,7 @@ public WarpingMomentOfInertia(double value, UnitSystem unitSystem)
         public double Value => _value;
 
         /// <inheritdoc />
-        QuantityValue IQuantity.Value => _value;
+        double IQuantity.Value => _value;
 
         Enum IQuantity.Unit => Unit;
 
@@ -261,60 +261,54 @@ public static string GetAbbreviation(WarpingMomentOfInertiaUnit unit, IFormatPro
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.CentimeterToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromCentimetersToTheSixth(QuantityValue centimeterstothesixth)
+        public static WarpingMomentOfInertia FromCentimetersToTheSixth(double centimeterstothesixth)
         {
-            double value = (double) centimeterstothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
+            return new WarpingMomentOfInertia(centimeterstothesixth, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.DecimeterToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromDecimetersToTheSixth(QuantityValue decimeterstothesixth)
+        public static WarpingMomentOfInertia FromDecimetersToTheSixth(double decimeterstothesixth)
         {
-            double value = (double) decimeterstothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
+            return new WarpingMomentOfInertia(decimeterstothesixth, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.FootToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromFeetToTheSixth(QuantityValue feettothesixth)
+        public static WarpingMomentOfInertia FromFeetToTheSixth(double feettothesixth)
         {
-            double value = (double) feettothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.FootToTheSixth);
+            return new WarpingMomentOfInertia(feettothesixth, WarpingMomentOfInertiaUnit.FootToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.InchToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromInchesToTheSixth(QuantityValue inchestothesixth)
+        public static WarpingMomentOfInertia FromInchesToTheSixth(double inchestothesixth)
         {
-            double value = (double) inchestothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.InchToTheSixth);
+            return new WarpingMomentOfInertia(inchestothesixth, WarpingMomentOfInertiaUnit.InchToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.MeterToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromMetersToTheSixth(QuantityValue meterstothesixth)
+        public static WarpingMomentOfInertia FromMetersToTheSixth(double meterstothesixth)
         {
-            double value = (double) meterstothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MeterToTheSixth);
+            return new WarpingMomentOfInertia(meterstothesixth, WarpingMomentOfInertiaUnit.MeterToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.MillimeterToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromMillimetersToTheSixth(QuantityValue millimeterstothesixth)
+        public static WarpingMomentOfInertia FromMillimetersToTheSixth(double millimeterstothesixth)
         {
-            double value = (double) millimeterstothesixth;
-            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
+            return new WarpingMomentOfInertia(millimeterstothesixth, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
         }
 
         /// <summary>
@@ -323,9 +317,9 @@ public static WarpingMomentOfInertia FromMillimetersToTheSixth(QuantityValue mil
         /// <param name="value">Value to convert from.</param>
         /// <param name="fromUnit">Unit to convert from.</param>
         /// <returns>WarpingMomentOfInertia unit value.</returns>
-        public static WarpingMomentOfInertia From(QuantityValue value, WarpingMomentOfInertiaUnit fromUnit)
+        public static WarpingMomentOfInertia From(double value, WarpingMomentOfInertiaUnit fromUnit)
         {
-            return new WarpingMomentOfInertia((double)value, fromUnit);
+            return new WarpingMomentOfInertia(value, fromUnit);
         }
 
         #endregion
@@ -736,15 +730,6 @@ public double As(UnitSystem unitSystem)
 
         /// <inheritdoc />
         double IQuantity.As(Enum unit)
-        {
-            if (!(unit is WarpingMomentOfInertiaUnit typedUnit))
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(WarpingMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return (double)As(typedUnit);
-        }
-
-        /// <inheritdoc />
-        double IValueQuantity<double>.As(Enum unit)
         {
             if (!(unit is WarpingMomentOfInertiaUnit typedUnit))
                 throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(WarpingMomentOfInertiaUnit)} is supported.", nameof(unit));
@@ -869,18 +854,6 @@ public WarpingMomentOfInertia ToUnit(UnitSystem unitSystem)
         /// <inheritdoc />
         IQuantity<WarpingMomentOfInertiaUnit> IQuantity<WarpingMomentOfInertiaUnit>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
 
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(Enum unit)
-        {
-            if (unit is not WarpingMomentOfInertiaUnit typedUnit)
-                throw new ArgumentException($"The given unit is of type {unit.GetType()}. Only {typeof(WarpingMomentOfInertiaUnit)} is supported.", nameof(unit));
-
-            return ToUnit(typedUnit);
-        }
-
-        /// <inheritdoc />
-        IValueQuantity<double> IValueQuantity<double>.ToUnit(UnitSystem unitSystem) => ToUnit(unitSystem);
-
         #endregion
 
         #region ToString Methods
diff --git a/UnitsNet/GeneratedCode/Quantity.g.cs b/UnitsNet/GeneratedCode/Quantity.g.cs
index 3f09a75aa4..8f90900f35 100644
--- a/UnitsNet/GeneratedCode/Quantity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantity.g.cs
@@ -169,7 +169,7 @@ public partial class Quantity
         /// <param name="quantityInfo">The <see cref="QuantityInfo"/> of the quantity to create.</param>
         /// <param name="value">The value to construct the quantity with.</param>
         /// <returns>The created quantity.</returns>
-        public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValue value)
+        public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, double value)
         {
             return quantityInfo.Name switch
             {
@@ -307,7 +307,7 @@ public static IQuantity FromQuantityInfo(QuantityInfo quantityInfo, QuantityValu
         /// <param name="unit">Unit enum value.</param>
         /// <param name="quantity">The resulting quantity if successful, otherwise <c>default</c>.</param>
         /// <returns><c>True</c> if successful with <paramref name="quantity"/> assigned the value, otherwise <c>false</c>.</returns>
-        public static bool TryFrom(QuantityValue value, Enum? unit, [NotNullWhen(true)] out IQuantity? quantity)
+        public static bool TryFrom(double value, Enum? unit, [NotNullWhen(true)] out IQuantity? quantity)
         {
             quantity = unit switch
             {

From 2c9685afc5566af719d61d5e0eb23a13ffc77be7 Mon Sep 17 00:00:00 2001
From: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>
Date: Fri, 23 Feb 2024 21:45:32 +0100
Subject: [PATCH 08/11] Add back test cases in UnitsNetBaseJsonConvertTests

They were not specific to decimal, adapted to work with double values.
---
 .../UnitsNetBaseJsonConverterTest.cs          | 107 ++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
index 112f65de2a..f6f6707788 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
@@ -37,6 +37,16 @@ public void UnitsNetBaseJsonConverter_ConvertIQuantity_throws_ArgumentNullExcept
             Assert.Equal("Value cannot be null. (Parameter 'quantity')", result.Message);
         }
 
+        [Fact]
+        public void UnitsNetBaseJsonConverter_ConvertValueUnit_works_as_expected()
+        {
+            var result = _sut.Test_ConvertDoubleValueUnit("PowerUnit.Watt", 10.2365);
+
+            Assert.NotNull(result);
+            Assert.IsType<Power>(result);
+            Assert.True(Power.FromWatts(10.2365).Equals((Power)result, 1e-5, ComparisonType.Absolute));
+        }
+
         [Fact]
         public void UnitsNetBaseJsonConverter_ConvertValueUnit_throws_UnitsNetException_when_unit_does_not_exist()
         {
@@ -47,6 +57,16 @@ public void UnitsNetBaseJsonConverter_ConvertValueUnit_throws_UnitsNetException_
             Assert.Equal("UnitsNet.Units.SomeImaginaryUnit,UnitsNet", result.Data["type"]);
         }
 
+        [Fact]
+        public void UnitsNetBaseJsonConverter_ConvertValueUnit_throws_UnitsNetException_when_unit_is_in_unexpected_format()
+        {
+            var result = Assert.Throws<UnitsNetException>(() => _sut.Test_ConvertDoubleValueUnit("PowerUnit Watt", 10.2365));
+
+            Assert.Equal("\"PowerUnit Watt\" is not a valid unit.", result.Message);
+            Assert.True(result.Data.Contains("type"));
+            Assert.Equal("PowerUnit Watt", result.Data["type"]);
+        }
+
         [Fact]
         public void UnitsNetBaseJsonConverter_CreateLocalSerializer_works_as_expected()
         {
@@ -86,6 +106,48 @@ public void UnitsNetBaseJsonConverter_ReadValueUnit_works_with_double_quantity()
             Assert.Equal(10.2365, result?.Value);
         }
 
+        /// <summary>
+        ///     Testing backwards compatibility with deserializing <see cref="decimal"/> based quantity JSON into <see cref="double"/> based quantities.
+        ///     <br/><br/>
+        ///     In v5 and below, there were 3 <see cref="decimal"/> based quantities <see cref="Power"/>, <see cref="Information"/> and <see cref="BitRate"/>.
+        ///     Since JSON does not support decimal values, the JSON schema emitted the value as a string instead of a number and included a 'ValueType'
+        ///     discriminator to describe whether the value was double or decimal.
+        ///     <br/><br/>
+        ///     <see cref="double"/> based quantities were serialized with <see cref="UnitsNetBaseJsonConverter{T}.ValueUnit"/> DTO, with <c>double Value</c> + <c>string Unit</c> properties.<br />
+        ///     <see cref="decimal"/> based quantities were serialized with <see cref="UnitsNetBaseJsonConverter{T}.ExtendedValueUnit"/> DTO, extending with ValueString and ValueType properties.
+        /// </summary>
+        [Fact]
+        public void UnitsNetBaseJsonConverter_ReadValueUnit_works_with_legacy_decimal_quantity()
+        {
+            var token = new JObject {{"Unit", "PowerUnit.Watt"}, {"Value", 10.2365}, {"ValueString", "10.2365"}, {"ValueType", "decimal"}};
+
+            var result = _sut.Test_ReadDoubleValueUnit(token);
+
+            Assert.NotNull(result);
+            Assert.Equal("PowerUnit.Watt", result?.Unit);
+            Assert.Equal(10.2365, result?.Value);
+        }
+
+        [Fact]
+        public void UnitsNetBaseJsonConverter_ReadValueUnit_returns_null_when_value_is_a_string()
+        {
+            var token = new JObject {{"Unit", "PowerUnit.Watt"}, {"Value", "10.2365"}};
+
+            var result = _sut.Test_ReadDoubleValueUnit(token);
+
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void UnitsNetBaseJsonConverter_ReadValueUnit_returns_null_when_value_type_is_not_a_string()
+        {
+            var token = new JObject {{"Unit", "PowerUnit.Watt"}, {"Value", 10.2365}, {"ValueType", 123}};
+
+            var result = _sut.Test_ReadDoubleValueUnit(token);
+
+            Assert.Null(result);
+        }
+
         [Fact]
         public void UnitsNetBaseJsonConverter_ReadDoubleValueUnit_works_with_empty_token()
         {
@@ -96,6 +158,51 @@ public void UnitsNetBaseJsonConverter_ReadDoubleValueUnit_works_with_empty_token
             Assert.Null(result);
         }
 
+        [Theory]
+        [InlineData(false, true)]
+        [InlineData(true, false)]
+        public void UnitsNetBaseJsonConverter_ReadValueUnit_returns_null_when_unit_or_value_is_missing(bool withUnit, bool withValue)
+        {
+            var token = new JObject();
+
+            if (withUnit)
+            {
+                token.Add("Unit", "PowerUnit.Watt");
+            }
+
+            if (withValue)
+            {
+                token.Add("Value", 10.2365);
+            }
+
+            var result = _sut.Test_ReadDoubleValueUnit(token);
+
+            Assert.Null(result);
+        }
+
+        [Theory]
+        [InlineData("Unit", "Value")]
+        [InlineData("unit", "Value")]
+        [InlineData("Unit", "value")]
+        [InlineData("unit", "value")]
+        [InlineData("unIT", "vAlUe")]
+        public void UnitsNetBaseJsonConverter_ReadValueUnit_works_case_insensitive(
+            string unitPropertyName,
+            string valuePropertyName)
+        {
+            var token = new JObject
+            {
+                {unitPropertyName, "PowerUnit.Watt"},
+                {valuePropertyName, 10.2365},
+            };
+
+            var result = _sut.Test_ReadDoubleValueUnit(token);
+
+            Assert.NotNull(result);
+            Assert.Equal("PowerUnit.Watt", result?.Unit);
+            Assert.Equal(10.2365, result?.Value);
+        }
+
         /// <summary>
         /// Dummy converter, used to access protected methods on abstract UnitsNetBaseJsonConverter{T}
         /// </summary>

From 9f2824de313e54173d767b860fd0bb1f1bf8e5d6 Mon Sep 17 00:00:00 2001
From: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>
Date: Fri, 23 Feb 2024 21:48:58 +0100
Subject: [PATCH 09/11] Rename FromXxx argument to value

---
 .../UnitsNetGen/QuantityGenerator.cs          |   7 +-
 .../AbsorbedDoseOfIonizingRadiation.g.cs      |  64 ++---
 .../Quantities/Acceleration.g.cs              |  56 ++--
 .../Quantities/AmountOfSubstance.g.cs         |  68 ++---
 .../Quantities/AmplitudeRatio.g.cs            |  16 +-
 UnitsNet/GeneratedCode/Quantities/Angle.g.cs  |  64 ++---
 .../Quantities/ApparentEnergy.g.cs            |  12 +-
 .../Quantities/ApparentPower.g.cs             |  24 +-
 UnitsNet/GeneratedCode/Quantities/Area.g.cs   |  56 ++--
 .../GeneratedCode/Quantities/AreaDensity.g.cs |  12 +-
 .../Quantities/AreaMomentOfInertia.g.cs       |  24 +-
 .../GeneratedCode/Quantities/BitRate.g.cs     | 104 +++----
 .../BrakeSpecificFuelConsumption.g.cs         |  12 +-
 .../GeneratedCode/Quantities/Capacitance.g.cs |  28 +-
 .../CoefficientOfThermalExpansion.g.cs        |  36 +--
 .../Quantities/Compressibility.g.cs           |  28 +-
 .../GeneratedCode/Quantities/Density.g.cs     | 224 +++++++--------
 .../GeneratedCode/Quantities/Duration.g.cs    |  44 +--
 .../Quantities/DynamicViscosity.g.cs          |  40 +--
 .../Quantities/ElectricAdmittance.g.cs        |  16 +-
 .../Quantities/ElectricCharge.g.cs            |  44 +--
 .../Quantities/ElectricChargeDensity.g.cs     |   4 +-
 .../Quantities/ElectricConductance.g.cs       |  20 +-
 .../Quantities/ElectricConductivity.g.cs      |  24 +-
 .../Quantities/ElectricCurrent.g.cs           |  36 +--
 .../Quantities/ElectricCurrentDensity.g.cs    |  12 +-
 .../Quantities/ElectricCurrentGradient.g.cs   |  28 +-
 .../Quantities/ElectricField.g.cs             |   4 +-
 .../Quantities/ElectricInductance.g.cs        |  20 +-
 .../Quantities/ElectricPotential.g.cs         |  24 +-
 .../Quantities/ElectricPotentialAc.g.cs       |  20 +-
 .../ElectricPotentialChangeRate.g.cs          |  80 +++---
 .../Quantities/ElectricPotentialDc.g.cs       |  20 +-
 .../Quantities/ElectricResistance.g.cs        |  28 +-
 .../Quantities/ElectricResistivity.g.cs       |  56 ++--
 .../ElectricSurfaceChargeDensity.g.cs         |  12 +-
 UnitsNet/GeneratedCode/Quantities/Energy.g.cs | 160 +++++------
 .../Quantities/EnergyDensity.g.cs             |  48 ++--
 .../GeneratedCode/Quantities/Entropy.g.cs     |  28 +-
 UnitsNet/GeneratedCode/Quantities/Force.g.cs  |  60 ++--
 .../Quantities/ForceChangeRate.g.cs           |  60 ++--
 .../Quantities/ForcePerLength.g.cs            | 152 +++++-----
 .../GeneratedCode/Quantities/Frequency.g.cs   |  52 ++--
 .../Quantities/FuelEfficiency.g.cs            |  16 +-
 .../GeneratedCode/Quantities/HeatFlux.g.cs    |  72 ++---
 .../Quantities/HeatTransferCoefficient.g.cs   |  24 +-
 .../GeneratedCode/Quantities/Illuminance.g.cs |  16 +-
 .../GeneratedCode/Quantities/Impulse.g.cs     |  52 ++--
 .../GeneratedCode/Quantities/Information.g.cs | 104 +++----
 .../GeneratedCode/Quantities/Irradiance.g.cs  |  56 ++--
 .../GeneratedCode/Quantities/Irradiation.g.cs |  28 +-
 UnitsNet/GeneratedCode/Quantities/Jerk.g.cs   |  44 +--
 .../Quantities/KinematicViscosity.g.cs        |  36 +--
 .../GeneratedCode/Quantities/LeakRate.g.cs    |  12 +-
 UnitsNet/GeneratedCode/Quantities/Length.g.cs | 168 +++++------
 UnitsNet/GeneratedCode/Quantities/Level.g.cs  |   8 +-
 .../Quantities/LinearDensity.g.cs             |  56 ++--
 .../Quantities/LinearPowerDensity.g.cs        | 100 +++----
 .../GeneratedCode/Quantities/Luminance.g.cs   |  40 +--
 .../GeneratedCode/Quantities/Luminosity.g.cs  |  56 ++--
 .../Quantities/LuminousFlux.g.cs              |   4 +-
 .../Quantities/LuminousIntensity.g.cs         |   4 +-
 .../Quantities/MagneticField.g.cs             |  24 +-
 .../Quantities/MagneticFlux.g.cs              |   4 +-
 .../Quantities/Magnetization.g.cs             |   4 +-
 UnitsNet/GeneratedCode/Quantities/Mass.g.cs   | 108 +++----
 .../Quantities/MassConcentration.g.cs         | 196 ++++++-------
 .../GeneratedCode/Quantities/MassFlow.g.cs    | 132 ++++-----
 .../GeneratedCode/Quantities/MassFlux.g.cs    |  48 ++--
 .../Quantities/MassFraction.g.cs              |  96 +++----
 .../Quantities/MassMomentOfInertia.g.cs       | 112 ++++----
 .../GeneratedCode/Quantities/Molality.g.cs    |   8 +-
 .../GeneratedCode/Quantities/MolarEnergy.g.cs |  12 +-
 .../Quantities/MolarEntropy.g.cs              |  12 +-
 .../GeneratedCode/Quantities/MolarFlow.g.cs   |  36 +--
 .../GeneratedCode/Quantities/MolarMass.g.cs   |  52 ++--
 .../GeneratedCode/Quantities/Molarity.g.cs    |  44 +--
 .../Quantities/Permeability.g.cs              |   4 +-
 .../Quantities/Permittivity.g.cs              |   4 +-
 .../Quantities/PorousMediumPermeability.g.cs  |  20 +-
 UnitsNet/GeneratedCode/Quantities/Power.g.cs  | 104 +++----
 .../Quantities/PowerDensity.g.cs              | 176 ++++++------
 .../GeneratedCode/Quantities/PowerRatio.g.cs  |   8 +-
 .../GeneratedCode/Quantities/Pressure.g.cs    | 196 ++++++-------
 .../Quantities/PressureChangeRate.g.cs        |  72 ++---
 .../Quantities/RadiationExposure.g.cs         |  32 +--
 .../Quantities/Radioactivity.g.cs             | 116 ++++----
 UnitsNet/GeneratedCode/Quantities/Ratio.g.cs  |  24 +-
 .../Quantities/RatioChangeRate.g.cs           |   8 +-
 .../Quantities/ReactiveEnergy.g.cs            |  12 +-
 .../Quantities/ReactivePower.g.cs             |  16 +-
 .../Quantities/ReciprocalArea.g.cs            |  44 +--
 .../Quantities/ReciprocalLength.g.cs          |  40 +--
 .../Quantities/RelativeHumidity.g.cs          |   4 +-
 .../Quantities/RotationalAcceleration.g.cs    |  16 +-
 .../Quantities/RotationalSpeed.g.cs           |  52 ++--
 .../Quantities/RotationalStiffness.g.cs       | 132 ++++-----
 .../RotationalStiffnessPerLength.g.cs         |  20 +-
 UnitsNet/GeneratedCode/Quantities/Scalar.g.cs |   4 +-
 .../GeneratedCode/Quantities/SolidAngle.g.cs  |   4 +-
 .../Quantities/SpecificEnergy.g.cs            | 120 ++++----
 .../Quantities/SpecificEntropy.g.cs           |  36 +--
 .../Quantities/SpecificFuelConsumption.g.cs   |  16 +-
 .../Quantities/SpecificVolume.g.cs            |  12 +-
 .../Quantities/SpecificWeight.g.cs            |  68 ++---
 UnitsNet/GeneratedCode/Quantities/Speed.g.cs  | 132 ++++-----
 .../Quantities/StandardVolumeFlow.g.cs        |  36 +--
 .../GeneratedCode/Quantities/Temperature.g.cs |  40 +--
 .../Quantities/TemperatureChangeRate.g.cs     |  40 +--
 .../Quantities/TemperatureDelta.g.cs          |  36 +--
 .../Quantities/TemperatureGradient.g.cs       |  16 +-
 .../Quantities/ThermalConductivity.g.cs       |   8 +-
 .../Quantities/ThermalResistance.g.cs         |  24 +-
 UnitsNet/GeneratedCode/Quantities/Torque.g.cs | 100 +++----
 .../Quantities/TorquePerLength.g.cs           |  84 +++---
 .../GeneratedCode/Quantities/Turbidity.g.cs   |   4 +-
 .../GeneratedCode/Quantities/VitaminA.g.cs    |   4 +-
 UnitsNet/GeneratedCode/Quantities/Volume.g.cs | 216 +++++++-------
 .../Quantities/VolumeConcentration.g.cs       |  80 +++---
 .../GeneratedCode/Quantities/VolumeFlow.g.cs  | 268 +++++++++---------
 .../Quantities/VolumeFlowPerArea.g.cs         |   8 +-
 .../Quantities/VolumePerLength.g.cs           |  36 +--
 .../Quantities/VolumetricHeatCapacity.g.cs    |  36 +--
 .../Quantities/WarpingMomentOfInertia.g.cs    |  24 +-
 124 files changed, 3131 insertions(+), 3132 deletions(-)

diff --git a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
index 72a9b5cfdc..e0d5f41066 100644
--- a/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
+++ b/CodeGen/Generators/UnitsNetGen/QuantityGenerator.cs
@@ -416,7 +416,6 @@ private void GenerateStaticFactoryMethods()
             {
                 if (unit.SkipConversionGeneration) continue;
 
-                var valueParamName = unit.PluralName.ToLowerInvariant();
                 Writer.WL($@"
         /// <summary>
         ///     Creates a <see cref=""{_quantity.Name}""/> from <see cref=""{_unitEnumName}.{unit.SingularName}""/>.
@@ -424,9 +423,9 @@ private void GenerateStaticFactoryMethods()
         /// <exception cref=""ArgumentException"">If value is NaN or Infinity.</exception>");
                 Writer.WLIfText(2, GetObsoleteAttributeOrNull(unit));
                 Writer.WL($@"
-        public static {_quantity.Name} From{unit.PluralName}(double {valueParamName})
+        public static {_quantity.Name} From{unit.PluralName}(double value)
         {{
-            return new {_quantity.Name}({valueParamName}, {_unitEnumName}.{unit.SingularName});
+            return new {_quantity.Name}(value, {_unitEnumName}.{unit.SingularName});
         }}
 ");
             }
@@ -777,7 +776,7 @@ private void GenerateRelationalOperators()
                     {
                         rightParameter = rightPart = "value";
                     }
-                    
+
                     var expression = $"{leftPart} {relation.Operator} {rightPart}";
 
                     if (relation.ResultQuantity.Name is not "double")
diff --git a/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs b/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
index cd1a5e3dc8..2946054ac8 100644
--- a/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AbsorbedDoseOfIonizingRadiation.g.cs
@@ -344,144 +344,144 @@ public static string GetAbbreviation(AbsorbedDoseOfIonizingRadiationUnit unit, I
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Centigray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromCentigrays(double centigrays)
+        public static AbsorbedDoseOfIonizingRadiation FromCentigrays(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(centigrays, AbsorbedDoseOfIonizingRadiationUnit.Centigray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Centigray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Femtogray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromFemtograys(double femtograys)
+        public static AbsorbedDoseOfIonizingRadiation FromFemtograys(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(femtograys, AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Femtogray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gigagray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromGigagrays(double gigagrays)
+        public static AbsorbedDoseOfIonizingRadiation FromGigagrays(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(gigagrays, AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Gigagray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Gray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromGrays(double grays)
+        public static AbsorbedDoseOfIonizingRadiation FromGrays(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(grays, AbsorbedDoseOfIonizingRadiationUnit.Gray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Gray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilogray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromKilograys(double kilograys)
+        public static AbsorbedDoseOfIonizingRadiation FromKilograys(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(kilograys, AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Kilogray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Kilorad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromKilorads(double kilorads)
+        public static AbsorbedDoseOfIonizingRadiation FromKilorads(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(kilorads, AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Kilorad);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megagray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMegagrays(double megagrays)
+        public static AbsorbedDoseOfIonizingRadiation FromMegagrays(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(megagrays, AbsorbedDoseOfIonizingRadiationUnit.Megagray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Megagray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Megarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMegarads(double megarads)
+        public static AbsorbedDoseOfIonizingRadiation FromMegarads(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(megarads, AbsorbedDoseOfIonizingRadiationUnit.Megarad);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Megarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Microgray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMicrograys(double micrograys)
+        public static AbsorbedDoseOfIonizingRadiation FromMicrograys(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(micrograys, AbsorbedDoseOfIonizingRadiationUnit.Microgray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Microgray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Milligray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMilligrays(double milligrays)
+        public static AbsorbedDoseOfIonizingRadiation FromMilligrays(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(milligrays, AbsorbedDoseOfIonizingRadiationUnit.Milligray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Milligray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Millirad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromMillirads(double millirads)
+        public static AbsorbedDoseOfIonizingRadiation FromMillirads(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(millirads, AbsorbedDoseOfIonizingRadiationUnit.Millirad);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Millirad);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Nanogray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromNanograys(double nanograys)
+        public static AbsorbedDoseOfIonizingRadiation FromNanograys(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(nanograys, AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Nanogray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Petagray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromPetagrays(double petagrays)
+        public static AbsorbedDoseOfIonizingRadiation FromPetagrays(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(petagrays, AbsorbedDoseOfIonizingRadiationUnit.Petagray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Petagray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Picogray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromPicograys(double picograys)
+        public static AbsorbedDoseOfIonizingRadiation FromPicograys(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(picograys, AbsorbedDoseOfIonizingRadiationUnit.Picogray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Picogray);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Rad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromRads(double rads)
+        public static AbsorbedDoseOfIonizingRadiation FromRads(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(rads, AbsorbedDoseOfIonizingRadiationUnit.Rad);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Rad);
         }
 
         /// <summary>
         ///     Creates a <see cref="AbsorbedDoseOfIonizingRadiation"/> from <see cref="AbsorbedDoseOfIonizingRadiationUnit.Teragray"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AbsorbedDoseOfIonizingRadiation FromTeragrays(double teragrays)
+        public static AbsorbedDoseOfIonizingRadiation FromTeragrays(double value)
         {
-            return new AbsorbedDoseOfIonizingRadiation(teragrays, AbsorbedDoseOfIonizingRadiationUnit.Teragray);
+            return new AbsorbedDoseOfIonizingRadiation(value, AbsorbedDoseOfIonizingRadiationUnit.Teragray);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
index 7c0dda39bc..9da774ea22 100644
--- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
@@ -336,126 +336,126 @@ public static string GetAbbreviation(AccelerationUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.CentimeterPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromCentimetersPerSecondSquared(double centimeterspersecondsquared)
+        public static Acceleration FromCentimetersPerSecondSquared(double value)
         {
-            return new Acceleration(centimeterspersecondsquared, AccelerationUnit.CentimeterPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.DecimeterPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromDecimetersPerSecondSquared(double decimeterspersecondsquared)
+        public static Acceleration FromDecimetersPerSecondSquared(double value)
         {
-            return new Acceleration(decimeterspersecondsquared, AccelerationUnit.DecimeterPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.FootPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromFeetPerSecondSquared(double feetpersecondsquared)
+        public static Acceleration FromFeetPerSecondSquared(double value)
         {
-            return new Acceleration(feetpersecondsquared, AccelerationUnit.FootPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.FootPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.InchPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromInchesPerSecondSquared(double inchespersecondsquared)
+        public static Acceleration FromInchesPerSecondSquared(double value)
         {
-            return new Acceleration(inchespersecondsquared, AccelerationUnit.InchPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.InchPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KilometerPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKilometersPerSecondSquared(double kilometerspersecondsquared)
+        public static Acceleration FromKilometersPerSecondSquared(double value)
         {
-            return new Acceleration(kilometerspersecondsquared, AccelerationUnit.KilometerPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerHour(double knotsperhour)
+        public static Acceleration FromKnotsPerHour(double value)
         {
-            return new Acceleration(knotsperhour, AccelerationUnit.KnotPerHour);
+            return new Acceleration(value, AccelerationUnit.KnotPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerMinute(double knotsperminute)
+        public static Acceleration FromKnotsPerMinute(double value)
         {
-            return new Acceleration(knotsperminute, AccelerationUnit.KnotPerMinute);
+            return new Acceleration(value, AccelerationUnit.KnotPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.KnotPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromKnotsPerSecond(double knotspersecond)
+        public static Acceleration FromKnotsPerSecond(double value)
         {
-            return new Acceleration(knotspersecond, AccelerationUnit.KnotPerSecond);
+            return new Acceleration(value, AccelerationUnit.KnotPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MeterPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMetersPerSecondSquared(double meterspersecondsquared)
+        public static Acceleration FromMetersPerSecondSquared(double value)
         {
-            return new Acceleration(meterspersecondsquared, AccelerationUnit.MeterPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MicrometerPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMicrometersPerSecondSquared(double micrometerspersecondsquared)
+        public static Acceleration FromMicrometersPerSecondSquared(double value)
         {
-            return new Acceleration(micrometerspersecondsquared, AccelerationUnit.MicrometerPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MillimeterPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMillimetersPerSecondSquared(double millimeterspersecondsquared)
+        public static Acceleration FromMillimetersPerSecondSquared(double value)
         {
-            return new Acceleration(millimeterspersecondsquared, AccelerationUnit.MillimeterPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.MillistandardGravity"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromMillistandardGravity(double millistandardgravity)
+        public static Acceleration FromMillistandardGravity(double value)
         {
-            return new Acceleration(millistandardgravity, AccelerationUnit.MillistandardGravity);
+            return new Acceleration(value, AccelerationUnit.MillistandardGravity);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.NanometerPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromNanometersPerSecondSquared(double nanometerspersecondsquared)
+        public static Acceleration FromNanometersPerSecondSquared(double value)
         {
-            return new Acceleration(nanometerspersecondsquared, AccelerationUnit.NanometerPerSecondSquared);
+            return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Acceleration"/> from <see cref="AccelerationUnit.StandardGravity"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Acceleration FromStandardGravity(double standardgravity)
+        public static Acceleration FromStandardGravity(double value)
         {
-            return new Acceleration(standardgravity, AccelerationUnit.StandardGravity);
+            return new Acceleration(value, AccelerationUnit.StandardGravity);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
index af5a890bd8..31bb489dc9 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmountOfSubstance.g.cs
@@ -357,153 +357,153 @@ public static string GetAbbreviation(AmountOfSubstanceUnit unit, IFormatProvider
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Centimole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromCentimoles(double centimoles)
+        public static AmountOfSubstance FromCentimoles(double value)
         {
-            return new AmountOfSubstance(centimoles, AmountOfSubstanceUnit.Centimole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Centimole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.CentipoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromCentipoundMoles(double centipoundmoles)
+        public static AmountOfSubstance FromCentipoundMoles(double value)
         {
-            return new AmountOfSubstance(centipoundmoles, AmountOfSubstanceUnit.CentipoundMole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.CentipoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Decimole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromDecimoles(double decimoles)
+        public static AmountOfSubstance FromDecimoles(double value)
         {
-            return new AmountOfSubstance(decimoles, AmountOfSubstanceUnit.Decimole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Decimole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.DecipoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromDecipoundMoles(double decipoundmoles)
+        public static AmountOfSubstance FromDecipoundMoles(double value)
         {
-            return new AmountOfSubstance(decipoundmoles, AmountOfSubstanceUnit.DecipoundMole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.DecipoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Femtomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromFemtomoles(double femtomoles)
+        public static AmountOfSubstance FromFemtomoles(double value)
         {
-            return new AmountOfSubstance(femtomoles, AmountOfSubstanceUnit.Femtomole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Femtomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Kilomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromKilomoles(double kilomoles)
+        public static AmountOfSubstance FromKilomoles(double value)
         {
-            return new AmountOfSubstance(kilomoles, AmountOfSubstanceUnit.Kilomole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Kilomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.KilopoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromKilopoundMoles(double kilopoundmoles)
+        public static AmountOfSubstance FromKilopoundMoles(double value)
         {
-            return new AmountOfSubstance(kilopoundmoles, AmountOfSubstanceUnit.KilopoundMole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.KilopoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Megamole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMegamoles(double megamoles)
+        public static AmountOfSubstance FromMegamoles(double value)
         {
-            return new AmountOfSubstance(megamoles, AmountOfSubstanceUnit.Megamole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Megamole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Micromole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMicromoles(double micromoles)
+        public static AmountOfSubstance FromMicromoles(double value)
         {
-            return new AmountOfSubstance(micromoles, AmountOfSubstanceUnit.Micromole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Micromole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.MicropoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMicropoundMoles(double micropoundmoles)
+        public static AmountOfSubstance FromMicropoundMoles(double value)
         {
-            return new AmountOfSubstance(micropoundmoles, AmountOfSubstanceUnit.MicropoundMole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.MicropoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Millimole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMillimoles(double millimoles)
+        public static AmountOfSubstance FromMillimoles(double value)
         {
-            return new AmountOfSubstance(millimoles, AmountOfSubstanceUnit.Millimole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Millimole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.MillipoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMillipoundMoles(double millipoundmoles)
+        public static AmountOfSubstance FromMillipoundMoles(double value)
         {
-            return new AmountOfSubstance(millipoundmoles, AmountOfSubstanceUnit.MillipoundMole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.MillipoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Mole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromMoles(double moles)
+        public static AmountOfSubstance FromMoles(double value)
         {
-            return new AmountOfSubstance(moles, AmountOfSubstanceUnit.Mole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Mole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Nanomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromNanomoles(double nanomoles)
+        public static AmountOfSubstance FromNanomoles(double value)
         {
-            return new AmountOfSubstance(nanomoles, AmountOfSubstanceUnit.Nanomole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Nanomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.NanopoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromNanopoundMoles(double nanopoundmoles)
+        public static AmountOfSubstance FromNanopoundMoles(double value)
         {
-            return new AmountOfSubstance(nanopoundmoles, AmountOfSubstanceUnit.NanopoundMole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.NanopoundMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.Picomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromPicomoles(double picomoles)
+        public static AmountOfSubstance FromPicomoles(double value)
         {
-            return new AmountOfSubstance(picomoles, AmountOfSubstanceUnit.Picomole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.Picomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmountOfSubstance"/> from <see cref="AmountOfSubstanceUnit.PoundMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmountOfSubstance FromPoundMoles(double poundmoles)
+        public static AmountOfSubstance FromPoundMoles(double value)
         {
-            return new AmountOfSubstance(poundmoles, AmountOfSubstanceUnit.PoundMole);
+            return new AmountOfSubstance(value, AmountOfSubstanceUnit.PoundMole);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
index 28965ce755..80fd371fb9 100644
--- a/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AmplitudeRatio.g.cs
@@ -245,36 +245,36 @@ public static string GetAbbreviation(AmplitudeRatioUnit unit, IFormatProvider? p
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelMicrovolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelMicrovolts(double decibelmicrovolts)
+        public static AmplitudeRatio FromDecibelMicrovolts(double value)
         {
-            return new AmplitudeRatio(decibelmicrovolts, AmplitudeRatioUnit.DecibelMicrovolt);
+            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMicrovolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelMillivolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelMillivolts(double decibelmillivolts)
+        public static AmplitudeRatio FromDecibelMillivolts(double value)
         {
-            return new AmplitudeRatio(decibelmillivolts, AmplitudeRatioUnit.DecibelMillivolt);
+            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelMillivolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelUnloaded"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelsUnloaded(double decibelsunloaded)
+        public static AmplitudeRatio FromDecibelsUnloaded(double value)
         {
-            return new AmplitudeRatio(decibelsunloaded, AmplitudeRatioUnit.DecibelUnloaded);
+            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelUnloaded);
         }
 
         /// <summary>
         ///     Creates a <see cref="AmplitudeRatio"/> from <see cref="AmplitudeRatioUnit.DecibelVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AmplitudeRatio FromDecibelVolts(double decibelvolts)
+        public static AmplitudeRatio FromDecibelVolts(double value)
         {
-            return new AmplitudeRatio(decibelvolts, AmplitudeRatioUnit.DecibelVolt);
+            return new AmplitudeRatio(value, AmplitudeRatioUnit.DecibelVolt);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
index 9154199798..4a885a77a6 100644
--- a/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Angle.g.cs
@@ -349,144 +349,144 @@ public static string GetAbbreviation(AngleUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Arcminute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromArcminutes(double arcminutes)
+        public static Angle FromArcminutes(double value)
         {
-            return new Angle(arcminutes, AngleUnit.Arcminute);
+            return new Angle(value, AngleUnit.Arcminute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Arcsecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromArcseconds(double arcseconds)
+        public static Angle FromArcseconds(double value)
         {
-            return new Angle(arcseconds, AngleUnit.Arcsecond);
+            return new Angle(value, AngleUnit.Arcsecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Centiradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromCentiradians(double centiradians)
+        public static Angle FromCentiradians(double value)
         {
-            return new Angle(centiradians, AngleUnit.Centiradian);
+            return new Angle(value, AngleUnit.Centiradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Deciradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromDeciradians(double deciradians)
+        public static Angle FromDeciradians(double value)
         {
-            return new Angle(deciradians, AngleUnit.Deciradian);
+            return new Angle(value, AngleUnit.Deciradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Degree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromDegrees(double degrees)
+        public static Angle FromDegrees(double value)
         {
-            return new Angle(degrees, AngleUnit.Degree);
+            return new Angle(value, AngleUnit.Degree);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Gradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromGradians(double gradians)
+        public static Angle FromGradians(double value)
         {
-            return new Angle(gradians, AngleUnit.Gradian);
+            return new Angle(value, AngleUnit.Gradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Microdegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMicrodegrees(double microdegrees)
+        public static Angle FromMicrodegrees(double value)
         {
-            return new Angle(microdegrees, AngleUnit.Microdegree);
+            return new Angle(value, AngleUnit.Microdegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Microradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMicroradians(double microradians)
+        public static Angle FromMicroradians(double value)
         {
-            return new Angle(microradians, AngleUnit.Microradian);
+            return new Angle(value, AngleUnit.Microradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Millidegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMillidegrees(double millidegrees)
+        public static Angle FromMillidegrees(double value)
         {
-            return new Angle(millidegrees, AngleUnit.Millidegree);
+            return new Angle(value, AngleUnit.Millidegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Milliradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromMilliradians(double milliradians)
+        public static Angle FromMilliradians(double value)
         {
-            return new Angle(milliradians, AngleUnit.Milliradian);
+            return new Angle(value, AngleUnit.Milliradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Nanodegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromNanodegrees(double nanodegrees)
+        public static Angle FromNanodegrees(double value)
         {
-            return new Angle(nanodegrees, AngleUnit.Nanodegree);
+            return new Angle(value, AngleUnit.Nanodegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Nanoradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromNanoradians(double nanoradians)
+        public static Angle FromNanoradians(double value)
         {
-            return new Angle(nanoradians, AngleUnit.Nanoradian);
+            return new Angle(value, AngleUnit.Nanoradian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.NatoMil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromNatoMils(double natomils)
+        public static Angle FromNatoMils(double value)
         {
-            return new Angle(natomils, AngleUnit.NatoMil);
+            return new Angle(value, AngleUnit.NatoMil);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Radian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromRadians(double radians)
+        public static Angle FromRadians(double value)
         {
-            return new Angle(radians, AngleUnit.Radian);
+            return new Angle(value, AngleUnit.Radian);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Revolution"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromRevolutions(double revolutions)
+        public static Angle FromRevolutions(double value)
         {
-            return new Angle(revolutions, AngleUnit.Revolution);
+            return new Angle(value, AngleUnit.Revolution);
         }
 
         /// <summary>
         ///     Creates a <see cref="Angle"/> from <see cref="AngleUnit.Tilt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Angle FromTilt(double tilt)
+        public static Angle FromTilt(double value)
         {
-            return new Angle(tilt, AngleUnit.Tilt);
+            return new Angle(value, AngleUnit.Tilt);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
index 368a86ea9f..dcd8442fbe 100644
--- a/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ApparentEnergy.g.cs
@@ -237,27 +237,27 @@ public static string GetAbbreviation(ApparentEnergyUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ApparentEnergy"/> from <see cref="ApparentEnergyUnit.KilovoltampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromKilovoltampereHours(double kilovoltamperehours)
+        public static ApparentEnergy FromKilovoltampereHours(double value)
         {
-            return new ApparentEnergy(kilovoltamperehours, ApparentEnergyUnit.KilovoltampereHour);
+            return new ApparentEnergy(value, ApparentEnergyUnit.KilovoltampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentEnergy"/> from <see cref="ApparentEnergyUnit.MegavoltampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromMegavoltampereHours(double megavoltamperehours)
+        public static ApparentEnergy FromMegavoltampereHours(double value)
         {
-            return new ApparentEnergy(megavoltamperehours, ApparentEnergyUnit.MegavoltampereHour);
+            return new ApparentEnergy(value, ApparentEnergyUnit.MegavoltampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentEnergy"/> from <see cref="ApparentEnergyUnit.VoltampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentEnergy FromVoltampereHours(double voltamperehours)
+        public static ApparentEnergy FromVoltampereHours(double value)
         {
-            return new ApparentEnergy(voltamperehours, ApparentEnergyUnit.VoltampereHour);
+            return new ApparentEnergy(value, ApparentEnergyUnit.VoltampereHour);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
index b05a40ab9e..196fde0960 100644
--- a/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ApparentPower.g.cs
@@ -261,54 +261,54 @@ public static string GetAbbreviation(ApparentPowerUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Gigavoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromGigavoltamperes(double gigavoltamperes)
+        public static ApparentPower FromGigavoltamperes(double value)
         {
-            return new ApparentPower(gigavoltamperes, ApparentPowerUnit.Gigavoltampere);
+            return new ApparentPower(value, ApparentPowerUnit.Gigavoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Kilovoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromKilovoltamperes(double kilovoltamperes)
+        public static ApparentPower FromKilovoltamperes(double value)
         {
-            return new ApparentPower(kilovoltamperes, ApparentPowerUnit.Kilovoltampere);
+            return new ApparentPower(value, ApparentPowerUnit.Kilovoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Megavoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromMegavoltamperes(double megavoltamperes)
+        public static ApparentPower FromMegavoltamperes(double value)
         {
-            return new ApparentPower(megavoltamperes, ApparentPowerUnit.Megavoltampere);
+            return new ApparentPower(value, ApparentPowerUnit.Megavoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Microvoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromMicrovoltamperes(double microvoltamperes)
+        public static ApparentPower FromMicrovoltamperes(double value)
         {
-            return new ApparentPower(microvoltamperes, ApparentPowerUnit.Microvoltampere);
+            return new ApparentPower(value, ApparentPowerUnit.Microvoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Millivoltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromMillivoltamperes(double millivoltamperes)
+        public static ApparentPower FromMillivoltamperes(double value)
         {
-            return new ApparentPower(millivoltamperes, ApparentPowerUnit.Millivoltampere);
+            return new ApparentPower(value, ApparentPowerUnit.Millivoltampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ApparentPower"/> from <see cref="ApparentPowerUnit.Voltampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ApparentPower FromVoltamperes(double voltamperes)
+        public static ApparentPower FromVoltamperes(double value)
         {
-            return new ApparentPower(voltamperes, ApparentPowerUnit.Voltampere);
+            return new ApparentPower(value, ApparentPowerUnit.Voltampere);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Area.g.cs b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
index 4f8c25c7a0..281f995046 100644
--- a/UnitsNet/GeneratedCode/Quantities/Area.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Area.g.cs
@@ -342,126 +342,126 @@ public static string GetAbbreviation(AreaUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.Acre"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromAcres(double acres)
+        public static Area FromAcres(double value)
         {
-            return new Area(acres, AreaUnit.Acre);
+            return new Area(value, AreaUnit.Acre);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.Hectare"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromHectares(double hectares)
+        public static Area FromHectares(double value)
         {
-            return new Area(hectares, AreaUnit.Hectare);
+            return new Area(value, AreaUnit.Hectare);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareCentimeters(double squarecentimeters)
+        public static Area FromSquareCentimeters(double value)
         {
-            return new Area(squarecentimeters, AreaUnit.SquareCentimeter);
+            return new Area(value, AreaUnit.SquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareDecimeters(double squaredecimeters)
+        public static Area FromSquareDecimeters(double value)
         {
-            return new Area(squaredecimeters, AreaUnit.SquareDecimeter);
+            return new Area(value, AreaUnit.SquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareFeet(double squarefeet)
+        public static Area FromSquareFeet(double value)
         {
-            return new Area(squarefeet, AreaUnit.SquareFoot);
+            return new Area(value, AreaUnit.SquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareInches(double squareinches)
+        public static Area FromSquareInches(double value)
         {
-            return new Area(squareinches, AreaUnit.SquareInch);
+            return new Area(value, AreaUnit.SquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareKilometers(double squarekilometers)
+        public static Area FromSquareKilometers(double value)
         {
-            return new Area(squarekilometers, AreaUnit.SquareKilometer);
+            return new Area(value, AreaUnit.SquareKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMeters(double squaremeters)
+        public static Area FromSquareMeters(double value)
         {
-            return new Area(squaremeters, AreaUnit.SquareMeter);
+            return new Area(value, AreaUnit.SquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMicrometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMicrometers(double squaremicrometers)
+        public static Area FromSquareMicrometers(double value)
         {
-            return new Area(squaremicrometers, AreaUnit.SquareMicrometer);
+            return new Area(value, AreaUnit.SquareMicrometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMiles(double squaremiles)
+        public static Area FromSquareMiles(double value)
         {
-            return new Area(squaremiles, AreaUnit.SquareMile);
+            return new Area(value, AreaUnit.SquareMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareMillimeters(double squaremillimeters)
+        public static Area FromSquareMillimeters(double value)
         {
-            return new Area(squaremillimeters, AreaUnit.SquareMillimeter);
+            return new Area(value, AreaUnit.SquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareNauticalMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareNauticalMiles(double squarenauticalmiles)
+        public static Area FromSquareNauticalMiles(double value)
         {
-            return new Area(squarenauticalmiles, AreaUnit.SquareNauticalMile);
+            return new Area(value, AreaUnit.SquareNauticalMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.SquareYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromSquareYards(double squareyards)
+        public static Area FromSquareYards(double value)
         {
-            return new Area(squareyards, AreaUnit.SquareYard);
+            return new Area(value, AreaUnit.SquareYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Area"/> from <see cref="AreaUnit.UsSurveySquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Area FromUsSurveySquareFeet(double ussurveysquarefeet)
+        public static Area FromUsSurveySquareFeet(double value)
         {
-            return new Area(ussurveysquarefeet, AreaUnit.UsSurveySquareFoot);
+            return new Area(value, AreaUnit.UsSurveySquareFoot);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
index dc3473d5dc..557e60eb93 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
@@ -243,27 +243,27 @@ public static string GetAbbreviation(AreaDensityUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.GramPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaDensity FromGramsPerSquareMeter(double gramspersquaremeter)
+        public static AreaDensity FromGramsPerSquareMeter(double value)
         {
-            return new AreaDensity(gramspersquaremeter, AreaDensityUnit.GramPerSquareMeter);
+            return new AreaDensity(value, AreaDensityUnit.GramPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.KilogramPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaDensity FromKilogramsPerSquareMeter(double kilogramspersquaremeter)
+        public static AreaDensity FromKilogramsPerSquareMeter(double value)
         {
-            return new AreaDensity(kilogramspersquaremeter, AreaDensityUnit.KilogramPerSquareMeter);
+            return new AreaDensity(value, AreaDensityUnit.KilogramPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaDensity"/> from <see cref="AreaDensityUnit.MilligramPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaDensity FromMilligramsPerSquareMeter(double milligramspersquaremeter)
+        public static AreaDensity FromMilligramsPerSquareMeter(double value)
         {
-            return new AreaDensity(milligramspersquaremeter, AreaDensityUnit.MilligramPerSquareMeter);
+            return new AreaDensity(value, AreaDensityUnit.MilligramPerSquareMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
index 78f1ad2b29..8ce16faf93 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaMomentOfInertia.g.cs
@@ -267,54 +267,54 @@ public static string GetAbbreviation(AreaMomentOfInertiaUnit unit, IFormatProvid
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.CentimeterToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromCentimetersToTheFourth(double centimeterstothefourth)
+        public static AreaMomentOfInertia FromCentimetersToTheFourth(double value)
         {
-            return new AreaMomentOfInertia(centimeterstothefourth, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
+            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.CentimeterToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.DecimeterToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromDecimetersToTheFourth(double decimeterstothefourth)
+        public static AreaMomentOfInertia FromDecimetersToTheFourth(double value)
         {
-            return new AreaMomentOfInertia(decimeterstothefourth, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
+            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.DecimeterToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.FootToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromFeetToTheFourth(double feettothefourth)
+        public static AreaMomentOfInertia FromFeetToTheFourth(double value)
         {
-            return new AreaMomentOfInertia(feettothefourth, AreaMomentOfInertiaUnit.FootToTheFourth);
+            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.FootToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.InchToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromInchesToTheFourth(double inchestothefourth)
+        public static AreaMomentOfInertia FromInchesToTheFourth(double value)
         {
-            return new AreaMomentOfInertia(inchestothefourth, AreaMomentOfInertiaUnit.InchToTheFourth);
+            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.InchToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.MeterToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromMetersToTheFourth(double meterstothefourth)
+        public static AreaMomentOfInertia FromMetersToTheFourth(double value)
         {
-            return new AreaMomentOfInertia(meterstothefourth, AreaMomentOfInertiaUnit.MeterToTheFourth);
+            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MeterToTheFourth);
         }
 
         /// <summary>
         ///     Creates a <see cref="AreaMomentOfInertia"/> from <see cref="AreaMomentOfInertiaUnit.MillimeterToTheFourth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static AreaMomentOfInertia FromMillimetersToTheFourth(double millimeterstothefourth)
+        public static AreaMomentOfInertia FromMillimetersToTheFourth(double value)
         {
-            return new AreaMomentOfInertia(millimeterstothefourth, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
+            return new AreaMomentOfInertia(value, AreaMomentOfInertiaUnit.MillimeterToTheFourth);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
index ccfb357344..25e8ea4743 100644
--- a/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BitRate.g.cs
@@ -424,234 +424,234 @@ public static string GetAbbreviation(BitRateUnit unit, IFormatProvider? provider
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.BitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromBitsPerSecond(double bitspersecond)
+        public static BitRate FromBitsPerSecond(double value)
         {
-            return new BitRate(bitspersecond, BitRateUnit.BitPerSecond);
+            return new BitRate(value, BitRateUnit.BitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.BytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromBytesPerSecond(double bytespersecond)
+        public static BitRate FromBytesPerSecond(double value)
         {
-            return new BitRate(bytespersecond, BitRateUnit.BytePerSecond);
+            return new BitRate(value, BitRateUnit.BytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExabitsPerSecond(double exabitspersecond)
+        public static BitRate FromExabitsPerSecond(double value)
         {
-            return new BitRate(exabitspersecond, BitRateUnit.ExabitPerSecond);
+            return new BitRate(value, BitRateUnit.ExabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExabytesPerSecond(double exabytespersecond)
+        public static BitRate FromExabytesPerSecond(double value)
         {
-            return new BitRate(exabytespersecond, BitRateUnit.ExabytePerSecond);
+            return new BitRate(value, BitRateUnit.ExabytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExbibitsPerSecond(double exbibitspersecond)
+        public static BitRate FromExbibitsPerSecond(double value)
         {
-            return new BitRate(exbibitspersecond, BitRateUnit.ExbibitPerSecond);
+            return new BitRate(value, BitRateUnit.ExbibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.ExbibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromExbibytesPerSecond(double exbibytespersecond)
+        public static BitRate FromExbibytesPerSecond(double value)
         {
-            return new BitRate(exbibytespersecond, BitRateUnit.ExbibytePerSecond);
+            return new BitRate(value, BitRateUnit.ExbibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGibibitsPerSecond(double gibibitspersecond)
+        public static BitRate FromGibibitsPerSecond(double value)
         {
-            return new BitRate(gibibitspersecond, BitRateUnit.GibibitPerSecond);
+            return new BitRate(value, BitRateUnit.GibibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GibibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGibibytesPerSecond(double gibibytespersecond)
+        public static BitRate FromGibibytesPerSecond(double value)
         {
-            return new BitRate(gibibytespersecond, BitRateUnit.GibibytePerSecond);
+            return new BitRate(value, BitRateUnit.GibibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGigabitsPerSecond(double gigabitspersecond)
+        public static BitRate FromGigabitsPerSecond(double value)
         {
-            return new BitRate(gigabitspersecond, BitRateUnit.GigabitPerSecond);
+            return new BitRate(value, BitRateUnit.GigabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.GigabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromGigabytesPerSecond(double gigabytespersecond)
+        public static BitRate FromGigabytesPerSecond(double value)
         {
-            return new BitRate(gigabytespersecond, BitRateUnit.GigabytePerSecond);
+            return new BitRate(value, BitRateUnit.GigabytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKibibitsPerSecond(double kibibitspersecond)
+        public static BitRate FromKibibitsPerSecond(double value)
         {
-            return new BitRate(kibibitspersecond, BitRateUnit.KibibitPerSecond);
+            return new BitRate(value, BitRateUnit.KibibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KibibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKibibytesPerSecond(double kibibytespersecond)
+        public static BitRate FromKibibytesPerSecond(double value)
         {
-            return new BitRate(kibibytespersecond, BitRateUnit.KibibytePerSecond);
+            return new BitRate(value, BitRateUnit.KibibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilobitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKilobitsPerSecond(double kilobitspersecond)
+        public static BitRate FromKilobitsPerSecond(double value)
         {
-            return new BitRate(kilobitspersecond, BitRateUnit.KilobitPerSecond);
+            return new BitRate(value, BitRateUnit.KilobitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.KilobytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromKilobytesPerSecond(double kilobytespersecond)
+        public static BitRate FromKilobytesPerSecond(double value)
         {
-            return new BitRate(kilobytespersecond, BitRateUnit.KilobytePerSecond);
+            return new BitRate(value, BitRateUnit.KilobytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMebibitsPerSecond(double mebibitspersecond)
+        public static BitRate FromMebibitsPerSecond(double value)
         {
-            return new BitRate(mebibitspersecond, BitRateUnit.MebibitPerSecond);
+            return new BitRate(value, BitRateUnit.MebibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MebibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMebibytesPerSecond(double mebibytespersecond)
+        public static BitRate FromMebibytesPerSecond(double value)
         {
-            return new BitRate(mebibytespersecond, BitRateUnit.MebibytePerSecond);
+            return new BitRate(value, BitRateUnit.MebibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMegabitsPerSecond(double megabitspersecond)
+        public static BitRate FromMegabitsPerSecond(double value)
         {
-            return new BitRate(megabitspersecond, BitRateUnit.MegabitPerSecond);
+            return new BitRate(value, BitRateUnit.MegabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.MegabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromMegabytesPerSecond(double megabytespersecond)
+        public static BitRate FromMegabytesPerSecond(double value)
         {
-            return new BitRate(megabytespersecond, BitRateUnit.MegabytePerSecond);
+            return new BitRate(value, BitRateUnit.MegabytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPebibitsPerSecond(double pebibitspersecond)
+        public static BitRate FromPebibitsPerSecond(double value)
         {
-            return new BitRate(pebibitspersecond, BitRateUnit.PebibitPerSecond);
+            return new BitRate(value, BitRateUnit.PebibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PebibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPebibytesPerSecond(double pebibytespersecond)
+        public static BitRate FromPebibytesPerSecond(double value)
         {
-            return new BitRate(pebibytespersecond, BitRateUnit.PebibytePerSecond);
+            return new BitRate(value, BitRateUnit.PebibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPetabitsPerSecond(double petabitspersecond)
+        public static BitRate FromPetabitsPerSecond(double value)
         {
-            return new BitRate(petabitspersecond, BitRateUnit.PetabitPerSecond);
+            return new BitRate(value, BitRateUnit.PetabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.PetabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromPetabytesPerSecond(double petabytespersecond)
+        public static BitRate FromPetabytesPerSecond(double value)
         {
-            return new BitRate(petabytespersecond, BitRateUnit.PetabytePerSecond);
+            return new BitRate(value, BitRateUnit.PetabytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebibitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTebibitsPerSecond(double tebibitspersecond)
+        public static BitRate FromTebibitsPerSecond(double value)
         {
-            return new BitRate(tebibitspersecond, BitRateUnit.TebibitPerSecond);
+            return new BitRate(value, BitRateUnit.TebibitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TebibytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTebibytesPerSecond(double tebibytespersecond)
+        public static BitRate FromTebibytesPerSecond(double value)
         {
-            return new BitRate(tebibytespersecond, BitRateUnit.TebibytePerSecond);
+            return new BitRate(value, BitRateUnit.TebibytePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TerabitPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTerabitsPerSecond(double terabitspersecond)
+        public static BitRate FromTerabitsPerSecond(double value)
         {
-            return new BitRate(terabitspersecond, BitRateUnit.TerabitPerSecond);
+            return new BitRate(value, BitRateUnit.TerabitPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="BitRate"/> from <see cref="BitRateUnit.TerabytePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BitRate FromTerabytesPerSecond(double terabytespersecond)
+        public static BitRate FromTerabytesPerSecond(double value)
         {
-            return new BitRate(terabytespersecond, BitRateUnit.TerabytePerSecond);
+            return new BitRate(value, BitRateUnit.TerabytePerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
index f206c16e94..712af22d80 100644
--- a/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/BrakeSpecificFuelConsumption.g.cs
@@ -244,27 +244,27 @@ public static string GetAbbreviation(BrakeSpecificFuelConsumptionUnit unit, IFor
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(double gramsperkilowatthour)
+        public static BrakeSpecificFuelConsumption FromGramsPerKiloWattHour(double value)
         {
-            return new BrakeSpecificFuelConsumption(gramsperkilowatthour, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
+            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.GramPerKiloWattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.KilogramPerJoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(double kilogramsperjoule)
+        public static BrakeSpecificFuelConsumption FromKilogramsPerJoule(double value)
         {
-            return new BrakeSpecificFuelConsumption(kilogramsperjoule, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
+            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.KilogramPerJoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="BrakeSpecificFuelConsumption"/> from <see cref="BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour(double poundspermechanicalhorsepowerhour)
+        public static BrakeSpecificFuelConsumption FromPoundsPerMechanicalHorsepowerHour(double value)
         {
-            return new BrakeSpecificFuelConsumption(poundspermechanicalhorsepowerhour, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
+            return new BrakeSpecificFuelConsumption(value, BrakeSpecificFuelConsumptionUnit.PoundPerMechanicalHorsepowerHour);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
index 8d9907fa89..e2ed75d852 100644
--- a/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Capacitance.g.cs
@@ -272,63 +272,63 @@ public static string GetAbbreviation(CapacitanceUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Farad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromFarads(double farads)
+        public static Capacitance FromFarads(double value)
         {
-            return new Capacitance(farads, CapacitanceUnit.Farad);
+            return new Capacitance(value, CapacitanceUnit.Farad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Kilofarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromKilofarads(double kilofarads)
+        public static Capacitance FromKilofarads(double value)
         {
-            return new Capacitance(kilofarads, CapacitanceUnit.Kilofarad);
+            return new Capacitance(value, CapacitanceUnit.Kilofarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Megafarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMegafarads(double megafarads)
+        public static Capacitance FromMegafarads(double value)
         {
-            return new Capacitance(megafarads, CapacitanceUnit.Megafarad);
+            return new Capacitance(value, CapacitanceUnit.Megafarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Microfarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMicrofarads(double microfarads)
+        public static Capacitance FromMicrofarads(double value)
         {
-            return new Capacitance(microfarads, CapacitanceUnit.Microfarad);
+            return new Capacitance(value, CapacitanceUnit.Microfarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Millifarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromMillifarads(double millifarads)
+        public static Capacitance FromMillifarads(double value)
         {
-            return new Capacitance(millifarads, CapacitanceUnit.Millifarad);
+            return new Capacitance(value, CapacitanceUnit.Millifarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Nanofarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromNanofarads(double nanofarads)
+        public static Capacitance FromNanofarads(double value)
         {
-            return new Capacitance(nanofarads, CapacitanceUnit.Nanofarad);
+            return new Capacitance(value, CapacitanceUnit.Nanofarad);
         }
 
         /// <summary>
         ///     Creates a <see cref="Capacitance"/> from <see cref="CapacitanceUnit.Picofarad"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Capacitance FromPicofarads(double picofarads)
+        public static Capacitance FromPicofarads(double value)
         {
-            return new Capacitance(picofarads, CapacitanceUnit.Picofarad);
+            return new Capacitance(value, CapacitanceUnit.Picofarad);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
index cbd02a5a19..1b66a2090a 100644
--- a/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/CoefficientOfThermalExpansion.g.cs
@@ -295,9 +295,9 @@ public static string GetAbbreviation(CoefficientOfThermalExpansionUnit unit, IFo
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         [Obsolete("Use PerDegreeCelsius instead.")]
-        public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(double inversedegreecelsius)
+        public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(double value)
         {
-            return new CoefficientOfThermalExpansion(inversedegreecelsius, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeCelsius);
         }
 
         /// <summary>
@@ -305,9 +305,9 @@ public static CoefficientOfThermalExpansion FromInverseDegreeCelsius(double inve
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         [Obsolete("Use PerDegreeFahrenheit instead.")]
-        public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(double inversedegreefahrenheit)
+        public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(double value)
         {
-            return new CoefficientOfThermalExpansion(inversedegreefahrenheit, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseDegreeFahrenheit);
         }
 
         /// <summary>
@@ -315,63 +315,63 @@ public static CoefficientOfThermalExpansion FromInverseDegreeFahrenheit(double i
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         [Obsolete("Use PerKelvin instead.")]
-        public static CoefficientOfThermalExpansion FromInverseKelvin(double inversekelvin)
+        public static CoefficientOfThermalExpansion FromInverseKelvin(double value)
         {
-            return new CoefficientOfThermalExpansion(inversekelvin, CoefficientOfThermalExpansionUnit.InverseKelvin);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.InverseKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPerDegreeCelsius(double perdegreecelsius)
+        public static CoefficientOfThermalExpansion FromPerDegreeCelsius(double value)
         {
-            return new CoefficientOfThermalExpansion(perdegreecelsius, CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPerDegreeFahrenheit(double perdegreefahrenheit)
+        public static CoefficientOfThermalExpansion FromPerDegreeFahrenheit(double value)
         {
-            return new CoefficientOfThermalExpansion(perdegreefahrenheit, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerDegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPerKelvin(double perkelvin)
+        public static CoefficientOfThermalExpansion FromPerKelvin(double value)
         {
-            return new CoefficientOfThermalExpansion(perkelvin, CoefficientOfThermalExpansionUnit.PerKelvin);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPpmPerDegreeCelsius(double ppmperdegreecelsius)
+        public static CoefficientOfThermalExpansion FromPpmPerDegreeCelsius(double value)
         {
-            return new CoefficientOfThermalExpansion(ppmperdegreecelsius, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPpmPerDegreeFahrenheit(double ppmperdegreefahrenheit)
+        public static CoefficientOfThermalExpansion FromPpmPerDegreeFahrenheit(double value)
         {
-            return new CoefficientOfThermalExpansion(ppmperdegreefahrenheit, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerDegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="CoefficientOfThermalExpansion"/> from <see cref="CoefficientOfThermalExpansionUnit.PpmPerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static CoefficientOfThermalExpansion FromPpmPerKelvin(double ppmperkelvin)
+        public static CoefficientOfThermalExpansion FromPpmPerKelvin(double value)
         {
-            return new CoefficientOfThermalExpansion(ppmperkelvin, CoefficientOfThermalExpansionUnit.PpmPerKelvin);
+            return new CoefficientOfThermalExpansion(value, CoefficientOfThermalExpansionUnit.PpmPerKelvin);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
index c0dd43106d..b5d7cae6c5 100644
--- a/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Compressibility.g.cs
@@ -269,63 +269,63 @@ public static string GetAbbreviation(CompressibilityUnit unit, IFormatProvider?
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseAtmosphere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseAtmospheres(double inverseatmospheres)
+        public static Compressibility FromInverseAtmospheres(double value)
         {
-            return new Compressibility(inverseatmospheres, CompressibilityUnit.InverseAtmosphere);
+            return new Compressibility(value, CompressibilityUnit.InverseAtmosphere);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseBar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseBars(double inversebars)
+        public static Compressibility FromInverseBars(double value)
         {
-            return new Compressibility(inversebars, CompressibilityUnit.InverseBar);
+            return new Compressibility(value, CompressibilityUnit.InverseBar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseKilopascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseKilopascals(double inversekilopascals)
+        public static Compressibility FromInverseKilopascals(double value)
         {
-            return new Compressibility(inversekilopascals, CompressibilityUnit.InverseKilopascal);
+            return new Compressibility(value, CompressibilityUnit.InverseKilopascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseMegapascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseMegapascals(double inversemegapascals)
+        public static Compressibility FromInverseMegapascals(double value)
         {
-            return new Compressibility(inversemegapascals, CompressibilityUnit.InverseMegapascal);
+            return new Compressibility(value, CompressibilityUnit.InverseMegapascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InverseMillibar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInverseMillibars(double inversemillibars)
+        public static Compressibility FromInverseMillibars(double value)
         {
-            return new Compressibility(inversemillibars, CompressibilityUnit.InverseMillibar);
+            return new Compressibility(value, CompressibilityUnit.InverseMillibar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InversePascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInversePascals(double inversepascals)
+        public static Compressibility FromInversePascals(double value)
         {
-            return new Compressibility(inversepascals, CompressibilityUnit.InversePascal);
+            return new Compressibility(value, CompressibilityUnit.InversePascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Compressibility"/> from <see cref="CompressibilityUnit.InversePoundForcePerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Compressibility FromInversePoundsForcePerSquareInch(double inversepoundsforcepersquareinch)
+        public static Compressibility FromInversePoundsForcePerSquareInch(double value)
         {
-            return new Compressibility(inversepoundsforcepersquareinch, CompressibilityUnit.InversePoundForcePerSquareInch);
+            return new Compressibility(value, CompressibilityUnit.InversePoundForcePerSquareInch);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
index f0760bf017..1b3c8a592d 100644
--- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
@@ -676,504 +676,504 @@ public static string GetAbbreviation(DensityUnit unit, IFormatProvider? provider
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerDeciliter(double centigramsperdeciliter)
+        public static Density FromCentigramsPerDeciliter(double value)
         {
-            return new Density(centigramsperdeciliter, DensityUnit.CentigramPerDeciliter);
+            return new Density(value, DensityUnit.CentigramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerLiter(double centigramsperliter)
+        public static Density FromCentigramsPerLiter(double value)
         {
-            return new Density(centigramsperliter, DensityUnit.CentigramPerLiter);
+            return new Density(value, DensityUnit.CentigramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.CentigramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromCentigramsPerMilliliter(double centigramspermilliliter)
+        public static Density FromCentigramsPerMilliliter(double value)
         {
-            return new Density(centigramspermilliliter, DensityUnit.CentigramPerMilliliter);
+            return new Density(value, DensityUnit.CentigramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerDeciliter(double decigramsperdeciliter)
+        public static Density FromDecigramsPerDeciliter(double value)
         {
-            return new Density(decigramsperdeciliter, DensityUnit.DecigramPerDeciliter);
+            return new Density(value, DensityUnit.DecigramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerLiter(double decigramsperliter)
+        public static Density FromDecigramsPerLiter(double value)
         {
-            return new Density(decigramsperliter, DensityUnit.DecigramPerLiter);
+            return new Density(value, DensityUnit.DecigramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.DecigramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromDecigramsPerMilliliter(double decigramspermilliliter)
+        public static Density FromDecigramsPerMilliliter(double value)
         {
-            return new Density(decigramspermilliliter, DensityUnit.DecigramPerMilliliter);
+            return new Density(value, DensityUnit.DecigramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromFemtogramsPerDeciliter(double femtogramsperdeciliter)
+        public static Density FromFemtogramsPerDeciliter(double value)
         {
-            return new Density(femtogramsperdeciliter, DensityUnit.FemtogramPerDeciliter);
+            return new Density(value, DensityUnit.FemtogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromFemtogramsPerLiter(double femtogramsperliter)
+        public static Density FromFemtogramsPerLiter(double value)
         {
-            return new Density(femtogramsperliter, DensityUnit.FemtogramPerLiter);
+            return new Density(value, DensityUnit.FemtogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.FemtogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromFemtogramsPerMilliliter(double femtogramspermilliliter)
+        public static Density FromFemtogramsPerMilliliter(double value)
         {
-            return new Density(femtogramspermilliliter, DensityUnit.FemtogramPerMilliliter);
+            return new Density(value, DensityUnit.FemtogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicCentimeter(double gramspercubiccentimeter)
+        public static Density FromGramsPerCubicCentimeter(double value)
         {
-            return new Density(gramspercubiccentimeter, DensityUnit.GramPerCubicCentimeter);
+            return new Density(value, DensityUnit.GramPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicFoot(double gramspercubicfoot)
+        public static Density FromGramsPerCubicFoot(double value)
         {
-            return new Density(gramspercubicfoot, DensityUnit.GramPerCubicFoot);
+            return new Density(value, DensityUnit.GramPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicInch(double gramspercubicinch)
+        public static Density FromGramsPerCubicInch(double value)
         {
-            return new Density(gramspercubicinch, DensityUnit.GramPerCubicInch);
+            return new Density(value, DensityUnit.GramPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicMeter(double gramspercubicmeter)
+        public static Density FromGramsPerCubicMeter(double value)
         {
-            return new Density(gramspercubicmeter, DensityUnit.GramPerCubicMeter);
+            return new Density(value, DensityUnit.GramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerCubicMillimeter(double gramspercubicmillimeter)
+        public static Density FromGramsPerCubicMillimeter(double value)
         {
-            return new Density(gramspercubicmillimeter, DensityUnit.GramPerCubicMillimeter);
+            return new Density(value, DensityUnit.GramPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerDeciliter(double gramsperdeciliter)
+        public static Density FromGramsPerDeciliter(double value)
         {
-            return new Density(gramsperdeciliter, DensityUnit.GramPerDeciliter);
+            return new Density(value, DensityUnit.GramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerLiter(double gramsperliter)
+        public static Density FromGramsPerLiter(double value)
         {
-            return new Density(gramsperliter, DensityUnit.GramPerLiter);
+            return new Density(value, DensityUnit.GramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.GramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromGramsPerMilliliter(double gramspermilliliter)
+        public static Density FromGramsPerMilliliter(double value)
         {
-            return new Density(gramspermilliliter, DensityUnit.GramPerMilliliter);
+            return new Density(value, DensityUnit.GramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicCentimeter(double kilogramspercubiccentimeter)
+        public static Density FromKilogramsPerCubicCentimeter(double value)
         {
-            return new Density(kilogramspercubiccentimeter, DensityUnit.KilogramPerCubicCentimeter);
+            return new Density(value, DensityUnit.KilogramPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicMeter(double kilogramspercubicmeter)
+        public static Density FromKilogramsPerCubicMeter(double value)
         {
-            return new Density(kilogramspercubicmeter, DensityUnit.KilogramPerCubicMeter);
+            return new Density(value, DensityUnit.KilogramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerCubicMillimeter(double kilogramspercubicmillimeter)
+        public static Density FromKilogramsPerCubicMillimeter(double value)
         {
-            return new Density(kilogramspercubicmillimeter, DensityUnit.KilogramPerCubicMillimeter);
+            return new Density(value, DensityUnit.KilogramPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilogramsPerLiter(double kilogramsperliter)
+        public static Density FromKilogramsPerLiter(double value)
         {
-            return new Density(kilogramsperliter, DensityUnit.KilogramPerLiter);
+            return new Density(value, DensityUnit.KilogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilopoundsPerCubicFoot(double kilopoundspercubicfoot)
+        public static Density FromKilopoundsPerCubicFoot(double value)
         {
-            return new Density(kilopoundspercubicfoot, DensityUnit.KilopoundPerCubicFoot);
+            return new Density(value, DensityUnit.KilopoundPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilopoundsPerCubicInch(double kilopoundspercubicinch)
+        public static Density FromKilopoundsPerCubicInch(double value)
         {
-            return new Density(kilopoundspercubicinch, DensityUnit.KilopoundPerCubicInch);
+            return new Density(value, DensityUnit.KilopoundPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.KilopoundPerCubicYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromKilopoundsPerCubicYard(double kilopoundspercubicyard)
+        public static Density FromKilopoundsPerCubicYard(double value)
         {
-            return new Density(kilopoundspercubicyard, DensityUnit.KilopoundPerCubicYard);
+            return new Density(value, DensityUnit.KilopoundPerCubicYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerCubicMeter(double microgramspercubicmeter)
+        public static Density FromMicrogramsPerCubicMeter(double value)
         {
-            return new Density(microgramspercubicmeter, DensityUnit.MicrogramPerCubicMeter);
+            return new Density(value, DensityUnit.MicrogramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerDeciliter(double microgramsperdeciliter)
+        public static Density FromMicrogramsPerDeciliter(double value)
         {
-            return new Density(microgramsperdeciliter, DensityUnit.MicrogramPerDeciliter);
+            return new Density(value, DensityUnit.MicrogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerLiter(double microgramsperliter)
+        public static Density FromMicrogramsPerLiter(double value)
         {
-            return new Density(microgramsperliter, DensityUnit.MicrogramPerLiter);
+            return new Density(value, DensityUnit.MicrogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MicrogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMicrogramsPerMilliliter(double microgramspermilliliter)
+        public static Density FromMicrogramsPerMilliliter(double value)
         {
-            return new Density(microgramspermilliliter, DensityUnit.MicrogramPerMilliliter);
+            return new Density(value, DensityUnit.MicrogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerCubicMeter(double milligramspercubicmeter)
+        public static Density FromMilligramsPerCubicMeter(double value)
         {
-            return new Density(milligramspercubicmeter, DensityUnit.MilligramPerCubicMeter);
+            return new Density(value, DensityUnit.MilligramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerDeciliter(double milligramsperdeciliter)
+        public static Density FromMilligramsPerDeciliter(double value)
         {
-            return new Density(milligramsperdeciliter, DensityUnit.MilligramPerDeciliter);
+            return new Density(value, DensityUnit.MilligramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerLiter(double milligramsperliter)
+        public static Density FromMilligramsPerLiter(double value)
         {
-            return new Density(milligramsperliter, DensityUnit.MilligramPerLiter);
+            return new Density(value, DensityUnit.MilligramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.MilligramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromMilligramsPerMilliliter(double milligramspermilliliter)
+        public static Density FromMilligramsPerMilliliter(double value)
         {
-            return new Density(milligramspermilliliter, DensityUnit.MilligramPerMilliliter);
+            return new Density(value, DensityUnit.MilligramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerDeciliter(double nanogramsperdeciliter)
+        public static Density FromNanogramsPerDeciliter(double value)
         {
-            return new Density(nanogramsperdeciliter, DensityUnit.NanogramPerDeciliter);
+            return new Density(value, DensityUnit.NanogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerLiter(double nanogramsperliter)
+        public static Density FromNanogramsPerLiter(double value)
         {
-            return new Density(nanogramsperliter, DensityUnit.NanogramPerLiter);
+            return new Density(value, DensityUnit.NanogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.NanogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromNanogramsPerMilliliter(double nanogramspermilliliter)
+        public static Density FromNanogramsPerMilliliter(double value)
         {
-            return new Density(nanogramspermilliliter, DensityUnit.NanogramPerMilliliter);
+            return new Density(value, DensityUnit.NanogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerDeciliter(double picogramsperdeciliter)
+        public static Density FromPicogramsPerDeciliter(double value)
         {
-            return new Density(picogramsperdeciliter, DensityUnit.PicogramPerDeciliter);
+            return new Density(value, DensityUnit.PicogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerLiter(double picogramsperliter)
+        public static Density FromPicogramsPerLiter(double value)
         {
-            return new Density(picogramsperliter, DensityUnit.PicogramPerLiter);
+            return new Density(value, DensityUnit.PicogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PicogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPicogramsPerMilliliter(double picogramspermilliliter)
+        public static Density FromPicogramsPerMilliliter(double value)
         {
-            return new Density(picogramspermilliliter, DensityUnit.PicogramPerMilliliter);
+            return new Density(value, DensityUnit.PicogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicCentimeter(double poundspercubiccentimeter)
+        public static Density FromPoundsPerCubicCentimeter(double value)
         {
-            return new Density(poundspercubiccentimeter, DensityUnit.PoundPerCubicCentimeter);
+            return new Density(value, DensityUnit.PoundPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicFoot(double poundspercubicfoot)
+        public static Density FromPoundsPerCubicFoot(double value)
         {
-            return new Density(poundspercubicfoot, DensityUnit.PoundPerCubicFoot);
+            return new Density(value, DensityUnit.PoundPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicInch(double poundspercubicinch)
+        public static Density FromPoundsPerCubicInch(double value)
         {
-            return new Density(poundspercubicinch, DensityUnit.PoundPerCubicInch);
+            return new Density(value, DensityUnit.PoundPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicMeter(double poundspercubicmeter)
+        public static Density FromPoundsPerCubicMeter(double value)
         {
-            return new Density(poundspercubicmeter, DensityUnit.PoundPerCubicMeter);
+            return new Density(value, DensityUnit.PoundPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicMillimeter(double poundspercubicmillimeter)
+        public static Density FromPoundsPerCubicMillimeter(double value)
         {
-            return new Density(poundspercubicmillimeter, DensityUnit.PoundPerCubicMillimeter);
+            return new Density(value, DensityUnit.PoundPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerCubicYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerCubicYard(double poundspercubicyard)
+        public static Density FromPoundsPerCubicYard(double value)
         {
-            return new Density(poundspercubicyard, DensityUnit.PoundPerCubicYard);
+            return new Density(value, DensityUnit.PoundPerCubicYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerImperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerImperialGallon(double poundsperimperialgallon)
+        public static Density FromPoundsPerImperialGallon(double value)
         {
-            return new Density(poundsperimperialgallon, DensityUnit.PoundPerImperialGallon);
+            return new Density(value, DensityUnit.PoundPerImperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.PoundPerUSGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromPoundsPerUSGallon(double poundsperusgallon)
+        public static Density FromPoundsPerUSGallon(double value)
         {
-            return new Density(poundsperusgallon, DensityUnit.PoundPerUSGallon);
+            return new Density(value, DensityUnit.PoundPerUSGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicCentimeter(double slugspercubiccentimeter)
+        public static Density FromSlugsPerCubicCentimeter(double value)
         {
-            return new Density(slugspercubiccentimeter, DensityUnit.SlugPerCubicCentimeter);
+            return new Density(value, DensityUnit.SlugPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicFoot(double slugspercubicfoot)
+        public static Density FromSlugsPerCubicFoot(double value)
         {
-            return new Density(slugspercubicfoot, DensityUnit.SlugPerCubicFoot);
+            return new Density(value, DensityUnit.SlugPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicInch(double slugspercubicinch)
+        public static Density FromSlugsPerCubicInch(double value)
         {
-            return new Density(slugspercubicinch, DensityUnit.SlugPerCubicInch);
+            return new Density(value, DensityUnit.SlugPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicMeter(double slugspercubicmeter)
+        public static Density FromSlugsPerCubicMeter(double value)
         {
-            return new Density(slugspercubicmeter, DensityUnit.SlugPerCubicMeter);
+            return new Density(value, DensityUnit.SlugPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.SlugPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromSlugsPerCubicMillimeter(double slugspercubicmillimeter)
+        public static Density FromSlugsPerCubicMillimeter(double value)
         {
-            return new Density(slugspercubicmillimeter, DensityUnit.SlugPerCubicMillimeter);
+            return new Density(value, DensityUnit.SlugPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicCentimeter(double tonnespercubiccentimeter)
+        public static Density FromTonnesPerCubicCentimeter(double value)
         {
-            return new Density(tonnespercubiccentimeter, DensityUnit.TonnePerCubicCentimeter);
+            return new Density(value, DensityUnit.TonnePerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicFoot(double tonnespercubicfoot)
+        public static Density FromTonnesPerCubicFoot(double value)
         {
-            return new Density(tonnespercubicfoot, DensityUnit.TonnePerCubicFoot);
+            return new Density(value, DensityUnit.TonnePerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicInch(double tonnespercubicinch)
+        public static Density FromTonnesPerCubicInch(double value)
         {
-            return new Density(tonnespercubicinch, DensityUnit.TonnePerCubicInch);
+            return new Density(value, DensityUnit.TonnePerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicMeter(double tonnespercubicmeter)
+        public static Density FromTonnesPerCubicMeter(double value)
         {
-            return new Density(tonnespercubicmeter, DensityUnit.TonnePerCubicMeter);
+            return new Density(value, DensityUnit.TonnePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Density"/> from <see cref="DensityUnit.TonnePerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Density FromTonnesPerCubicMillimeter(double tonnespercubicmillimeter)
+        public static Density FromTonnesPerCubicMillimeter(double value)
         {
-            return new Density(tonnespercubicmillimeter, DensityUnit.TonnePerCubicMillimeter);
+            return new Density(value, DensityUnit.TonnePerCubicMillimeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
index ed094880bb..85029f0a63 100644
--- a/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Duration.g.cs
@@ -319,99 +319,99 @@ public static string GetAbbreviation(DurationUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Day"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromDays(double days)
+        public static Duration FromDays(double value)
         {
-            return new Duration(days, DurationUnit.Day);
+            return new Duration(value, DurationUnit.Day);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Hour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromHours(double hours)
+        public static Duration FromHours(double value)
         {
-            return new Duration(hours, DurationUnit.Hour);
+            return new Duration(value, DurationUnit.Hour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.JulianYear"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromJulianYears(double julianyears)
+        public static Duration FromJulianYears(double value)
         {
-            return new Duration(julianyears, DurationUnit.JulianYear);
+            return new Duration(value, DurationUnit.JulianYear);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Microsecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMicroseconds(double microseconds)
+        public static Duration FromMicroseconds(double value)
         {
-            return new Duration(microseconds, DurationUnit.Microsecond);
+            return new Duration(value, DurationUnit.Microsecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Millisecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMilliseconds(double milliseconds)
+        public static Duration FromMilliseconds(double value)
         {
-            return new Duration(milliseconds, DurationUnit.Millisecond);
+            return new Duration(value, DurationUnit.Millisecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Minute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMinutes(double minutes)
+        public static Duration FromMinutes(double value)
         {
-            return new Duration(minutes, DurationUnit.Minute);
+            return new Duration(value, DurationUnit.Minute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Month30"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromMonths30(double months30)
+        public static Duration FromMonths30(double value)
         {
-            return new Duration(months30, DurationUnit.Month30);
+            return new Duration(value, DurationUnit.Month30);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Nanosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromNanoseconds(double nanoseconds)
+        public static Duration FromNanoseconds(double value)
         {
-            return new Duration(nanoseconds, DurationUnit.Nanosecond);
+            return new Duration(value, DurationUnit.Nanosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Second"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromSeconds(double seconds)
+        public static Duration FromSeconds(double value)
         {
-            return new Duration(seconds, DurationUnit.Second);
+            return new Duration(value, DurationUnit.Second);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Week"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromWeeks(double weeks)
+        public static Duration FromWeeks(double value)
         {
-            return new Duration(weeks, DurationUnit.Week);
+            return new Duration(value, DurationUnit.Week);
         }
 
         /// <summary>
         ///     Creates a <see cref="Duration"/> from <see cref="DurationUnit.Year365"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Duration FromYears365(double years365)
+        public static Duration FromYears365(double value)
         {
-            return new Duration(years365, DurationUnit.Year365);
+            return new Duration(value, DurationUnit.Year365);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
index 982af348d6..e3b9e103ac 100644
--- a/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/DynamicViscosity.g.cs
@@ -302,90 +302,90 @@ public static string GetAbbreviation(DynamicViscosityUnit unit, IFormatProvider?
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Centipoise"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromCentipoise(double centipoise)
+        public static DynamicViscosity FromCentipoise(double value)
         {
-            return new DynamicViscosity(centipoise, DynamicViscosityUnit.Centipoise);
+            return new DynamicViscosity(value, DynamicViscosityUnit.Centipoise);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.MicropascalSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromMicropascalSeconds(double micropascalseconds)
+        public static DynamicViscosity FromMicropascalSeconds(double value)
         {
-            return new DynamicViscosity(micropascalseconds, DynamicViscosityUnit.MicropascalSecond);
+            return new DynamicViscosity(value, DynamicViscosityUnit.MicropascalSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.MillipascalSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromMillipascalSeconds(double millipascalseconds)
+        public static DynamicViscosity FromMillipascalSeconds(double value)
         {
-            return new DynamicViscosity(millipascalseconds, DynamicViscosityUnit.MillipascalSecond);
+            return new DynamicViscosity(value, DynamicViscosityUnit.MillipascalSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.NewtonSecondPerMeterSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromNewtonSecondsPerMeterSquared(double newtonsecondspermetersquared)
+        public static DynamicViscosity FromNewtonSecondsPerMeterSquared(double value)
         {
-            return new DynamicViscosity(newtonsecondspermetersquared, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
+            return new DynamicViscosity(value, DynamicViscosityUnit.NewtonSecondPerMeterSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PascalSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPascalSeconds(double pascalseconds)
+        public static DynamicViscosity FromPascalSeconds(double value)
         {
-            return new DynamicViscosity(pascalseconds, DynamicViscosityUnit.PascalSecond);
+            return new DynamicViscosity(value, DynamicViscosityUnit.PascalSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Poise"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoise(double poise)
+        public static DynamicViscosity FromPoise(double value)
         {
-            return new DynamicViscosity(poise, DynamicViscosityUnit.Poise);
+            return new DynamicViscosity(value, DynamicViscosityUnit.Poise);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(double poundsforcesecondpersquarefoot)
+        public static DynamicViscosity FromPoundsForceSecondPerSquareFoot(double value)
         {
-            return new DynamicViscosity(poundsforcesecondpersquarefoot, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
+            return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundForceSecondPerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsForceSecondPerSquareInch(double poundsforcesecondpersquareinch)
+        public static DynamicViscosity FromPoundsForceSecondPerSquareInch(double value)
         {
-            return new DynamicViscosity(poundsforcesecondpersquareinch, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
+            return new DynamicViscosity(value, DynamicViscosityUnit.PoundForceSecondPerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.PoundPerFootSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromPoundsPerFootSecond(double poundsperfootsecond)
+        public static DynamicViscosity FromPoundsPerFootSecond(double value)
         {
-            return new DynamicViscosity(poundsperfootsecond, DynamicViscosityUnit.PoundPerFootSecond);
+            return new DynamicViscosity(value, DynamicViscosityUnit.PoundPerFootSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="DynamicViscosity"/> from <see cref="DynamicViscosityUnit.Reyn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static DynamicViscosity FromReyns(double reyns)
+        public static DynamicViscosity FromReyns(double value)
         {
-            return new DynamicViscosity(reyns, DynamicViscosityUnit.Reyn);
+            return new DynamicViscosity(value, DynamicViscosityUnit.Reyn);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
index fd7f91d288..03b7123ae4 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricAdmittance.g.cs
@@ -245,36 +245,36 @@ public static string GetAbbreviation(ElectricAdmittanceUnit unit, IFormatProvide
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Microsiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromMicrosiemens(double microsiemens)
+        public static ElectricAdmittance FromMicrosiemens(double value)
         {
-            return new ElectricAdmittance(microsiemens, ElectricAdmittanceUnit.Microsiemens);
+            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Microsiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Millisiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromMillisiemens(double millisiemens)
+        public static ElectricAdmittance FromMillisiemens(double value)
         {
-            return new ElectricAdmittance(millisiemens, ElectricAdmittanceUnit.Millisiemens);
+            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Millisiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Nanosiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromNanosiemens(double nanosiemens)
+        public static ElectricAdmittance FromNanosiemens(double value)
         {
-            return new ElectricAdmittance(nanosiemens, ElectricAdmittanceUnit.Nanosiemens);
+            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Nanosiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricAdmittance"/> from <see cref="ElectricAdmittanceUnit.Siemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricAdmittance FromSiemens(double siemens)
+        public static ElectricAdmittance FromSiemens(double value)
         {
-            return new ElectricAdmittance(siemens, ElectricAdmittanceUnit.Siemens);
+            return new ElectricAdmittance(value, ElectricAdmittanceUnit.Siemens);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
index dde56c8b82..e5c4251ad8 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCharge.g.cs
@@ -313,99 +313,99 @@ public static string GetAbbreviation(ElectricChargeUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.AmpereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromAmpereHours(double amperehours)
+        public static ElectricCharge FromAmpereHours(double value)
         {
-            return new ElectricCharge(amperehours, ElectricChargeUnit.AmpereHour);
+            return new ElectricCharge(value, ElectricChargeUnit.AmpereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Coulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromCoulombs(double coulombs)
+        public static ElectricCharge FromCoulombs(double value)
         {
-            return new ElectricCharge(coulombs, ElectricChargeUnit.Coulomb);
+            return new ElectricCharge(value, ElectricChargeUnit.Coulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.KiloampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromKiloampereHours(double kiloamperehours)
+        public static ElectricCharge FromKiloampereHours(double value)
         {
-            return new ElectricCharge(kiloamperehours, ElectricChargeUnit.KiloampereHour);
+            return new ElectricCharge(value, ElectricChargeUnit.KiloampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Kilocoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromKilocoulombs(double kilocoulombs)
+        public static ElectricCharge FromKilocoulombs(double value)
         {
-            return new ElectricCharge(kilocoulombs, ElectricChargeUnit.Kilocoulomb);
+            return new ElectricCharge(value, ElectricChargeUnit.Kilocoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.MegaampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMegaampereHours(double megaamperehours)
+        public static ElectricCharge FromMegaampereHours(double value)
         {
-            return new ElectricCharge(megaamperehours, ElectricChargeUnit.MegaampereHour);
+            return new ElectricCharge(value, ElectricChargeUnit.MegaampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Megacoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMegacoulombs(double megacoulombs)
+        public static ElectricCharge FromMegacoulombs(double value)
         {
-            return new ElectricCharge(megacoulombs, ElectricChargeUnit.Megacoulomb);
+            return new ElectricCharge(value, ElectricChargeUnit.Megacoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Microcoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMicrocoulombs(double microcoulombs)
+        public static ElectricCharge FromMicrocoulombs(double value)
         {
-            return new ElectricCharge(microcoulombs, ElectricChargeUnit.Microcoulomb);
+            return new ElectricCharge(value, ElectricChargeUnit.Microcoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.MilliampereHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMilliampereHours(double milliamperehours)
+        public static ElectricCharge FromMilliampereHours(double value)
         {
-            return new ElectricCharge(milliamperehours, ElectricChargeUnit.MilliampereHour);
+            return new ElectricCharge(value, ElectricChargeUnit.MilliampereHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Millicoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromMillicoulombs(double millicoulombs)
+        public static ElectricCharge FromMillicoulombs(double value)
         {
-            return new ElectricCharge(millicoulombs, ElectricChargeUnit.Millicoulomb);
+            return new ElectricCharge(value, ElectricChargeUnit.Millicoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Nanocoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromNanocoulombs(double nanocoulombs)
+        public static ElectricCharge FromNanocoulombs(double value)
         {
-            return new ElectricCharge(nanocoulombs, ElectricChargeUnit.Nanocoulomb);
+            return new ElectricCharge(value, ElectricChargeUnit.Nanocoulomb);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCharge"/> from <see cref="ElectricChargeUnit.Picocoulomb"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCharge FromPicocoulombs(double picocoulombs)
+        public static ElectricCharge FromPicocoulombs(double value)
         {
-            return new ElectricCharge(picocoulombs, ElectricChargeUnit.Picocoulomb);
+            return new ElectricCharge(value, ElectricChargeUnit.Picocoulomb);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
index 0b7f5315d8..5d91680e82 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricChargeDensity.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(ElectricChargeDensityUnit unit, IFormatProv
         ///     Creates a <see cref="ElectricChargeDensity"/> from <see cref="ElectricChargeDensityUnit.CoulombPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricChargeDensity FromCoulombsPerCubicMeter(double coulombspercubicmeter)
+        public static ElectricChargeDensity FromCoulombsPerCubicMeter(double value)
         {
-            return new ElectricChargeDensity(coulombspercubicmeter, ElectricChargeDensityUnit.CoulombPerCubicMeter);
+            return new ElectricChargeDensity(value, ElectricChargeDensityUnit.CoulombPerCubicMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
index 7d3ecf9956..604f0d51f8 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductance.g.cs
@@ -256,45 +256,45 @@ public static string GetAbbreviation(ElectricConductanceUnit unit, IFormatProvid
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Kilosiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromKilosiemens(double kilosiemens)
+        public static ElectricConductance FromKilosiemens(double value)
         {
-            return new ElectricConductance(kilosiemens, ElectricConductanceUnit.Kilosiemens);
+            return new ElectricConductance(value, ElectricConductanceUnit.Kilosiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Microsiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromMicrosiemens(double microsiemens)
+        public static ElectricConductance FromMicrosiemens(double value)
         {
-            return new ElectricConductance(microsiemens, ElectricConductanceUnit.Microsiemens);
+            return new ElectricConductance(value, ElectricConductanceUnit.Microsiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Millisiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromMillisiemens(double millisiemens)
+        public static ElectricConductance FromMillisiemens(double value)
         {
-            return new ElectricConductance(millisiemens, ElectricConductanceUnit.Millisiemens);
+            return new ElectricConductance(value, ElectricConductanceUnit.Millisiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Nanosiemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromNanosiemens(double nanosiemens)
+        public static ElectricConductance FromNanosiemens(double value)
         {
-            return new ElectricConductance(nanosiemens, ElectricConductanceUnit.Nanosiemens);
+            return new ElectricConductance(value, ElectricConductanceUnit.Nanosiemens);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductance"/> from <see cref="ElectricConductanceUnit.Siemens"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductance FromSiemens(double siemens)
+        public static ElectricConductance FromSiemens(double value)
         {
-            return new ElectricConductance(siemens, ElectricConductanceUnit.Siemens);
+            return new ElectricConductance(value, ElectricConductanceUnit.Siemens);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
index 778999e06a..3ce5967489 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricConductivity.g.cs
@@ -264,54 +264,54 @@ public static string GetAbbreviation(ElectricConductivityUnit unit, IFormatProvi
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.MicrosiemensPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromMicrosiemensPerCentimeter(double microsiemenspercentimeter)
+        public static ElectricConductivity FromMicrosiemensPerCentimeter(double value)
         {
-            return new ElectricConductivity(microsiemenspercentimeter, ElectricConductivityUnit.MicrosiemensPerCentimeter);
+            return new ElectricConductivity(value, ElectricConductivityUnit.MicrosiemensPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.MillisiemensPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromMillisiemensPerCentimeter(double millisiemenspercentimeter)
+        public static ElectricConductivity FromMillisiemensPerCentimeter(double value)
         {
-            return new ElectricConductivity(millisiemenspercentimeter, ElectricConductivityUnit.MillisiemensPerCentimeter);
+            return new ElectricConductivity(value, ElectricConductivityUnit.MillisiemensPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerCentimeter(double siemenspercentimeter)
+        public static ElectricConductivity FromSiemensPerCentimeter(double value)
         {
-            return new ElectricConductivity(siemenspercentimeter, ElectricConductivityUnit.SiemensPerCentimeter);
+            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerFoot(double siemensperfoot)
+        public static ElectricConductivity FromSiemensPerFoot(double value)
         {
-            return new ElectricConductivity(siemensperfoot, ElectricConductivityUnit.SiemensPerFoot);
+            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerInch(double siemensperinch)
+        public static ElectricConductivity FromSiemensPerInch(double value)
         {
-            return new ElectricConductivity(siemensperinch, ElectricConductivityUnit.SiemensPerInch);
+            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricConductivity"/> from <see cref="ElectricConductivityUnit.SiemensPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricConductivity FromSiemensPerMeter(double siemenspermeter)
+        public static ElectricConductivity FromSiemensPerMeter(double value)
         {
-            return new ElectricConductivity(siemenspermeter, ElectricConductivityUnit.SiemensPerMeter);
+            return new ElectricConductivity(value, ElectricConductivityUnit.SiemensPerMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
index d5760a8a01..abc2e5d080 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrent.g.cs
@@ -296,81 +296,81 @@ public static string GetAbbreviation(ElectricCurrentUnit unit, IFormatProvider?
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Ampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromAmperes(double amperes)
+        public static ElectricCurrent FromAmperes(double value)
         {
-            return new ElectricCurrent(amperes, ElectricCurrentUnit.Ampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Ampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Centiampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromCentiamperes(double centiamperes)
+        public static ElectricCurrent FromCentiamperes(double value)
         {
-            return new ElectricCurrent(centiamperes, ElectricCurrentUnit.Centiampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Centiampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Femtoampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromFemtoamperes(double femtoamperes)
+        public static ElectricCurrent FromFemtoamperes(double value)
         {
-            return new ElectricCurrent(femtoamperes, ElectricCurrentUnit.Femtoampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Femtoampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Kiloampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromKiloamperes(double kiloamperes)
+        public static ElectricCurrent FromKiloamperes(double value)
         {
-            return new ElectricCurrent(kiloamperes, ElectricCurrentUnit.Kiloampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Kiloampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Megaampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMegaamperes(double megaamperes)
+        public static ElectricCurrent FromMegaamperes(double value)
         {
-            return new ElectricCurrent(megaamperes, ElectricCurrentUnit.Megaampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Megaampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Microampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMicroamperes(double microamperes)
+        public static ElectricCurrent FromMicroamperes(double value)
         {
-            return new ElectricCurrent(microamperes, ElectricCurrentUnit.Microampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Microampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Milliampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromMilliamperes(double milliamperes)
+        public static ElectricCurrent FromMilliamperes(double value)
         {
-            return new ElectricCurrent(milliamperes, ElectricCurrentUnit.Milliampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Milliampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Nanoampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromNanoamperes(double nanoamperes)
+        public static ElectricCurrent FromNanoamperes(double value)
         {
-            return new ElectricCurrent(nanoamperes, ElectricCurrentUnit.Nanoampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Nanoampere);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrent"/> from <see cref="ElectricCurrentUnit.Picoampere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrent FromPicoamperes(double picoamperes)
+        public static ElectricCurrent FromPicoamperes(double value)
         {
-            return new ElectricCurrent(picoamperes, ElectricCurrentUnit.Picoampere);
+            return new ElectricCurrent(value, ElectricCurrentUnit.Picoampere);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
index 5f0f5f3ebe..ba7c9b30f2 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentDensity.g.cs
@@ -240,27 +240,27 @@ public static string GetAbbreviation(ElectricCurrentDensityUnit unit, IFormatPro
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareFoot(double amperespersquarefoot)
+        public static ElectricCurrentDensity FromAmperesPerSquareFoot(double value)
         {
-            return new ElectricCurrentDensity(amperespersquarefoot, ElectricCurrentDensityUnit.AmperePerSquareFoot);
+            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareInch(double amperespersquareinch)
+        public static ElectricCurrentDensity FromAmperesPerSquareInch(double value)
         {
-            return new ElectricCurrentDensity(amperespersquareinch, ElectricCurrentDensityUnit.AmperePerSquareInch);
+            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentDensity"/> from <see cref="ElectricCurrentDensityUnit.AmperePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentDensity FromAmperesPerSquareMeter(double amperespersquaremeter)
+        public static ElectricCurrentDensity FromAmperesPerSquareMeter(double value)
         {
-            return new ElectricCurrentDensity(amperespersquaremeter, ElectricCurrentDensityUnit.AmperePerSquareMeter);
+            return new ElectricCurrentDensity(value, ElectricCurrentDensityUnit.AmperePerSquareMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
index a0715fa4e7..ee47836741 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricCurrentGradient.g.cs
@@ -276,63 +276,63 @@ public static string GetAbbreviation(ElectricCurrentGradientUnit unit, IFormatPr
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerMicrosecond(double amperespermicrosecond)
+        public static ElectricCurrentGradient FromAmperesPerMicrosecond(double value)
         {
-            return new ElectricCurrentGradient(amperespermicrosecond, ElectricCurrentGradientUnit.AmperePerMicrosecond);
+            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMillisecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerMillisecond(double amperespermillisecond)
+        public static ElectricCurrentGradient FromAmperesPerMillisecond(double value)
         {
-            return new ElectricCurrentGradient(amperespermillisecond, ElectricCurrentGradientUnit.AmperePerMillisecond);
+            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMillisecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerMinute(double amperesperminute)
+        public static ElectricCurrentGradient FromAmperesPerMinute(double value)
         {
-            return new ElectricCurrentGradient(amperesperminute, ElectricCurrentGradientUnit.AmperePerMinute);
+            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerNanosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerNanosecond(double amperespernanosecond)
+        public static ElectricCurrentGradient FromAmperesPerNanosecond(double value)
         {
-            return new ElectricCurrentGradient(amperespernanosecond, ElectricCurrentGradientUnit.AmperePerNanosecond);
+            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerNanosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.AmperePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromAmperesPerSecond(double amperespersecond)
+        public static ElectricCurrentGradient FromAmperesPerSecond(double value)
         {
-            return new ElectricCurrentGradient(amperespersecond, ElectricCurrentGradientUnit.AmperePerSecond);
+            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.AmperePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.MilliamperePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromMilliamperesPerMinute(double milliamperesperminute)
+        public static ElectricCurrentGradient FromMilliamperesPerMinute(double value)
         {
-            return new ElectricCurrentGradient(milliamperesperminute, ElectricCurrentGradientUnit.MilliamperePerMinute);
+            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.MilliamperePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricCurrentGradient"/> from <see cref="ElectricCurrentGradientUnit.MilliamperePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricCurrentGradient FromMilliamperesPerSecond(double milliamperespersecond)
+        public static ElectricCurrentGradient FromMilliamperesPerSecond(double value)
         {
-            return new ElectricCurrentGradient(milliamperespersecond, ElectricCurrentGradientUnit.MilliamperePerSecond);
+            return new ElectricCurrentGradient(value, ElectricCurrentGradientUnit.MilliamperePerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
index 1d73e8c481..bc2c96547d 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricField.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(ElectricFieldUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="ElectricField"/> from <see cref="ElectricFieldUnit.VoltPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricField FromVoltsPerMeter(double voltspermeter)
+        public static ElectricField FromVoltsPerMeter(double value)
         {
-            return new ElectricField(voltspermeter, ElectricFieldUnit.VoltPerMeter);
+            return new ElectricField(value, ElectricFieldUnit.VoltPerMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
index cef87cde96..8e9965dfd1 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricInductance.g.cs
@@ -256,45 +256,45 @@ public static string GetAbbreviation(ElectricInductanceUnit unit, IFormatProvide
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Henry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromHenries(double henries)
+        public static ElectricInductance FromHenries(double value)
         {
-            return new ElectricInductance(henries, ElectricInductanceUnit.Henry);
+            return new ElectricInductance(value, ElectricInductanceUnit.Henry);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Microhenry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromMicrohenries(double microhenries)
+        public static ElectricInductance FromMicrohenries(double value)
         {
-            return new ElectricInductance(microhenries, ElectricInductanceUnit.Microhenry);
+            return new ElectricInductance(value, ElectricInductanceUnit.Microhenry);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Millihenry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromMillihenries(double millihenries)
+        public static ElectricInductance FromMillihenries(double value)
         {
-            return new ElectricInductance(millihenries, ElectricInductanceUnit.Millihenry);
+            return new ElectricInductance(value, ElectricInductanceUnit.Millihenry);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Nanohenry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromNanohenries(double nanohenries)
+        public static ElectricInductance FromNanohenries(double value)
         {
-            return new ElectricInductance(nanohenries, ElectricInductanceUnit.Nanohenry);
+            return new ElectricInductance(value, ElectricInductanceUnit.Nanohenry);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricInductance"/> from <see cref="ElectricInductanceUnit.Picohenry"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricInductance FromPicohenries(double picohenries)
+        public static ElectricInductance FromPicohenries(double value)
         {
-            return new ElectricInductance(picohenries, ElectricInductanceUnit.Picohenry);
+            return new ElectricInductance(value, ElectricInductanceUnit.Picohenry);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
index 0fd783a39a..4a7d20dedf 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotential.g.cs
@@ -270,54 +270,54 @@ public static string GetAbbreviation(ElectricPotentialUnit unit, IFormatProvider
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Kilovolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromKilovolts(double kilovolts)
+        public static ElectricPotential FromKilovolts(double value)
         {
-            return new ElectricPotential(kilovolts, ElectricPotentialUnit.Kilovolt);
+            return new ElectricPotential(value, ElectricPotentialUnit.Kilovolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Megavolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMegavolts(double megavolts)
+        public static ElectricPotential FromMegavolts(double value)
         {
-            return new ElectricPotential(megavolts, ElectricPotentialUnit.Megavolt);
+            return new ElectricPotential(value, ElectricPotentialUnit.Megavolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Microvolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMicrovolts(double microvolts)
+        public static ElectricPotential FromMicrovolts(double value)
         {
-            return new ElectricPotential(microvolts, ElectricPotentialUnit.Microvolt);
+            return new ElectricPotential(value, ElectricPotentialUnit.Microvolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Millivolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromMillivolts(double millivolts)
+        public static ElectricPotential FromMillivolts(double value)
         {
-            return new ElectricPotential(millivolts, ElectricPotentialUnit.Millivolt);
+            return new ElectricPotential(value, ElectricPotentialUnit.Millivolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Nanovolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromNanovolts(double nanovolts)
+        public static ElectricPotential FromNanovolts(double value)
         {
-            return new ElectricPotential(nanovolts, ElectricPotentialUnit.Nanovolt);
+            return new ElectricPotential(value, ElectricPotentialUnit.Nanovolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotential"/> from <see cref="ElectricPotentialUnit.Volt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotential FromVolts(double volts)
+        public static ElectricPotential FromVolts(double value)
         {
-            return new ElectricPotential(volts, ElectricPotentialUnit.Volt);
+            return new ElectricPotential(value, ElectricPotentialUnit.Volt);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
index 529a67a34c..fd93ea730f 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialAc.g.cs
@@ -253,45 +253,45 @@ public static string GetAbbreviation(ElectricPotentialAcUnit unit, IFormatProvid
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.KilovoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromKilovoltsAc(double kilovoltsac)
+        public static ElectricPotentialAc FromKilovoltsAc(double value)
         {
-            return new ElectricPotentialAc(kilovoltsac, ElectricPotentialAcUnit.KilovoltAc);
+            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.KilovoltAc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.MegavoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMegavoltsAc(double megavoltsac)
+        public static ElectricPotentialAc FromMegavoltsAc(double value)
         {
-            return new ElectricPotentialAc(megavoltsac, ElectricPotentialAcUnit.MegavoltAc);
+            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MegavoltAc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.MicrovoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMicrovoltsAc(double microvoltsac)
+        public static ElectricPotentialAc FromMicrovoltsAc(double value)
         {
-            return new ElectricPotentialAc(microvoltsac, ElectricPotentialAcUnit.MicrovoltAc);
+            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MicrovoltAc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.MillivoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromMillivoltsAc(double millivoltsac)
+        public static ElectricPotentialAc FromMillivoltsAc(double value)
         {
-            return new ElectricPotentialAc(millivoltsac, ElectricPotentialAcUnit.MillivoltAc);
+            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.MillivoltAc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialAc"/> from <see cref="ElectricPotentialAcUnit.VoltAc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialAc FromVoltsAc(double voltsac)
+        public static ElectricPotentialAc FromVoltsAc(double value)
         {
-            return new ElectricPotentialAc(voltsac, ElectricPotentialAcUnit.VoltAc);
+            return new ElectricPotentialAc(value, ElectricPotentialAcUnit.VoltAc);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
index 876ccd5ebf..b6784e0d4f 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialChangeRate.g.cs
@@ -373,180 +373,180 @@ public static string GetAbbreviation(ElectricPotentialChangeRateUnit unit, IForm
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerHour(double kilovoltsperhour)
+        public static ElectricPotentialChangeRate FromKilovoltsPerHour(double value)
         {
-            return new ElectricPotentialChangeRate(kilovoltsperhour, ElectricPotentialChangeRateUnit.KilovoltPerHour);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(double kilovoltspermicrosecond)
+        public static ElectricPotentialChangeRate FromKilovoltsPerMicrosecond(double value)
         {
-            return new ElectricPotentialChangeRate(kilovoltspermicrosecond, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerMinute(double kilovoltsperminute)
+        public static ElectricPotentialChangeRate FromKilovoltsPerMinute(double value)
         {
-            return new ElectricPotentialChangeRate(kilovoltsperminute, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.KilovoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromKilovoltsPerSecond(double kilovoltspersecond)
+        public static ElectricPotentialChangeRate FromKilovoltsPerSecond(double value)
         {
-            return new ElectricPotentialChangeRate(kilovoltspersecond, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.KilovoltPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerHour(double megavoltsperhour)
+        public static ElectricPotentialChangeRate FromMegavoltsPerHour(double value)
         {
-            return new ElectricPotentialChangeRate(megavoltsperhour, ElectricPotentialChangeRateUnit.MegavoltPerHour);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(double megavoltspermicrosecond)
+        public static ElectricPotentialChangeRate FromMegavoltsPerMicrosecond(double value)
         {
-            return new ElectricPotentialChangeRate(megavoltspermicrosecond, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerMinute(double megavoltsperminute)
+        public static ElectricPotentialChangeRate FromMegavoltsPerMinute(double value)
         {
-            return new ElectricPotentialChangeRate(megavoltsperminute, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MegavoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMegavoltsPerSecond(double megavoltspersecond)
+        public static ElectricPotentialChangeRate FromMegavoltsPerSecond(double value)
         {
-            return new ElectricPotentialChangeRate(megavoltspersecond, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MegavoltPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerHour(double microvoltsperhour)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerHour(double value)
         {
-            return new ElectricPotentialChangeRate(microvoltsperhour, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(double microvoltspermicrosecond)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerMicrosecond(double value)
         {
-            return new ElectricPotentialChangeRate(microvoltspermicrosecond, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(double microvoltsperminute)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerMinute(double value)
         {
-            return new ElectricPotentialChangeRate(microvoltsperminute, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MicrovoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(double microvoltspersecond)
+        public static ElectricPotentialChangeRate FromMicrovoltsPerSecond(double value)
         {
-            return new ElectricPotentialChangeRate(microvoltspersecond, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MicrovoltPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerHour(double millivoltsperhour)
+        public static ElectricPotentialChangeRate FromMillivoltsPerHour(double value)
         {
-            return new ElectricPotentialChangeRate(millivoltsperhour, ElectricPotentialChangeRateUnit.MillivoltPerHour);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(double millivoltspermicrosecond)
+        public static ElectricPotentialChangeRate FromMillivoltsPerMicrosecond(double value)
         {
-            return new ElectricPotentialChangeRate(millivoltspermicrosecond, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerMinute(double millivoltsperminute)
+        public static ElectricPotentialChangeRate FromMillivoltsPerMinute(double value)
         {
-            return new ElectricPotentialChangeRate(millivoltsperminute, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.MillivoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromMillivoltsPerSecond(double millivoltspersecond)
+        public static ElectricPotentialChangeRate FromMillivoltsPerSecond(double value)
         {
-            return new ElectricPotentialChangeRate(millivoltspersecond, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.MillivoltPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerHour(double voltsperhour)
+        public static ElectricPotentialChangeRate FromVoltsPerHour(double value)
         {
-            return new ElectricPotentialChangeRate(voltsperhour, ElectricPotentialChangeRateUnit.VoltPerHour);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerMicrosecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(double voltspermicrosecond)
+        public static ElectricPotentialChangeRate FromVoltsPerMicrosecond(double value)
         {
-            return new ElectricPotentialChangeRate(voltspermicrosecond, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMicrosecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerMinute(double voltsperminute)
+        public static ElectricPotentialChangeRate FromVoltsPerMinute(double value)
         {
-            return new ElectricPotentialChangeRate(voltsperminute, ElectricPotentialChangeRateUnit.VoltPerMinute);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialChangeRate"/> from <see cref="ElectricPotentialChangeRateUnit.VoltPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialChangeRate FromVoltsPerSecond(double voltspersecond)
+        public static ElectricPotentialChangeRate FromVoltsPerSecond(double value)
         {
-            return new ElectricPotentialChangeRate(voltspersecond, ElectricPotentialChangeRateUnit.VoltPerSecond);
+            return new ElectricPotentialChangeRate(value, ElectricPotentialChangeRateUnit.VoltPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
index 63f8ddc2e6..c587100854 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricPotentialDc.g.cs
@@ -253,45 +253,45 @@ public static string GetAbbreviation(ElectricPotentialDcUnit unit, IFormatProvid
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.KilovoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromKilovoltsDc(double kilovoltsdc)
+        public static ElectricPotentialDc FromKilovoltsDc(double value)
         {
-            return new ElectricPotentialDc(kilovoltsdc, ElectricPotentialDcUnit.KilovoltDc);
+            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.KilovoltDc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.MegavoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMegavoltsDc(double megavoltsdc)
+        public static ElectricPotentialDc FromMegavoltsDc(double value)
         {
-            return new ElectricPotentialDc(megavoltsdc, ElectricPotentialDcUnit.MegavoltDc);
+            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MegavoltDc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.MicrovoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMicrovoltsDc(double microvoltsdc)
+        public static ElectricPotentialDc FromMicrovoltsDc(double value)
         {
-            return new ElectricPotentialDc(microvoltsdc, ElectricPotentialDcUnit.MicrovoltDc);
+            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MicrovoltDc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.MillivoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromMillivoltsDc(double millivoltsdc)
+        public static ElectricPotentialDc FromMillivoltsDc(double value)
         {
-            return new ElectricPotentialDc(millivoltsdc, ElectricPotentialDcUnit.MillivoltDc);
+            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.MillivoltDc);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricPotentialDc"/> from <see cref="ElectricPotentialDcUnit.VoltDc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricPotentialDc FromVoltsDc(double voltsdc)
+        public static ElectricPotentialDc FromVoltsDc(double value)
         {
-            return new ElectricPotentialDc(voltsdc, ElectricPotentialDcUnit.VoltDc);
+            return new ElectricPotentialDc(value, ElectricPotentialDcUnit.VoltDc);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
index ea9498d3a8..1773329f76 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistance.g.cs
@@ -275,63 +275,63 @@ public static string GetAbbreviation(ElectricResistanceUnit unit, IFormatProvide
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Gigaohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromGigaohms(double gigaohms)
+        public static ElectricResistance FromGigaohms(double value)
         {
-            return new ElectricResistance(gigaohms, ElectricResistanceUnit.Gigaohm);
+            return new ElectricResistance(value, ElectricResistanceUnit.Gigaohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Kiloohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromKiloohms(double kiloohms)
+        public static ElectricResistance FromKiloohms(double value)
         {
-            return new ElectricResistance(kiloohms, ElectricResistanceUnit.Kiloohm);
+            return new ElectricResistance(value, ElectricResistanceUnit.Kiloohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Megaohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMegaohms(double megaohms)
+        public static ElectricResistance FromMegaohms(double value)
         {
-            return new ElectricResistance(megaohms, ElectricResistanceUnit.Megaohm);
+            return new ElectricResistance(value, ElectricResistanceUnit.Megaohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Microohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMicroohms(double microohms)
+        public static ElectricResistance FromMicroohms(double value)
         {
-            return new ElectricResistance(microohms, ElectricResistanceUnit.Microohm);
+            return new ElectricResistance(value, ElectricResistanceUnit.Microohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Milliohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromMilliohms(double milliohms)
+        public static ElectricResistance FromMilliohms(double value)
         {
-            return new ElectricResistance(milliohms, ElectricResistanceUnit.Milliohm);
+            return new ElectricResistance(value, ElectricResistanceUnit.Milliohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Ohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromOhms(double ohms)
+        public static ElectricResistance FromOhms(double value)
         {
-            return new ElectricResistance(ohms, ElectricResistanceUnit.Ohm);
+            return new ElectricResistance(value, ElectricResistanceUnit.Ohm);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistance"/> from <see cref="ElectricResistanceUnit.Teraohm"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistance FromTeraohms(double teraohms)
+        public static ElectricResistance FromTeraohms(double value)
         {
-            return new ElectricResistance(teraohms, ElectricResistanceUnit.Teraohm);
+            return new ElectricResistance(value, ElectricResistanceUnit.Teraohm);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
index 8e569cbc49..600264c115 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricResistivity.g.cs
@@ -328,126 +328,126 @@ public static string GetAbbreviation(ElectricResistivityUnit unit, IFormatProvid
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.KiloohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromKiloohmsCentimeter(double kiloohmscentimeter)
+        public static ElectricResistivity FromKiloohmsCentimeter(double value)
         {
-            return new ElectricResistivity(kiloohmscentimeter, ElectricResistivityUnit.KiloohmCentimeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.KiloohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromKiloohmMeters(double kiloohmmeters)
+        public static ElectricResistivity FromKiloohmMeters(double value)
         {
-            return new ElectricResistivity(kiloohmmeters, ElectricResistivityUnit.KiloohmMeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.KiloohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MegaohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMegaohmsCentimeter(double megaohmscentimeter)
+        public static ElectricResistivity FromMegaohmsCentimeter(double value)
         {
-            return new ElectricResistivity(megaohmscentimeter, ElectricResistivityUnit.MegaohmCentimeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MegaohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMegaohmMeters(double megaohmmeters)
+        public static ElectricResistivity FromMegaohmMeters(double value)
         {
-            return new ElectricResistivity(megaohmmeters, ElectricResistivityUnit.MegaohmMeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.MegaohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MicroohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMicroohmsCentimeter(double microohmscentimeter)
+        public static ElectricResistivity FromMicroohmsCentimeter(double value)
         {
-            return new ElectricResistivity(microohmscentimeter, ElectricResistivityUnit.MicroohmCentimeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MicroohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMicroohmMeters(double microohmmeters)
+        public static ElectricResistivity FromMicroohmMeters(double value)
         {
-            return new ElectricResistivity(microohmmeters, ElectricResistivityUnit.MicroohmMeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.MicroohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MilliohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMilliohmsCentimeter(double milliohmscentimeter)
+        public static ElectricResistivity FromMilliohmsCentimeter(double value)
         {
-            return new ElectricResistivity(milliohmscentimeter, ElectricResistivityUnit.MilliohmCentimeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.MilliohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromMilliohmMeters(double milliohmmeters)
+        public static ElectricResistivity FromMilliohmMeters(double value)
         {
-            return new ElectricResistivity(milliohmmeters, ElectricResistivityUnit.MilliohmMeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.MilliohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.NanoohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromNanoohmsCentimeter(double nanoohmscentimeter)
+        public static ElectricResistivity FromNanoohmsCentimeter(double value)
         {
-            return new ElectricResistivity(nanoohmscentimeter, ElectricResistivityUnit.NanoohmCentimeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.NanoohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromNanoohmMeters(double nanoohmmeters)
+        public static ElectricResistivity FromNanoohmMeters(double value)
         {
-            return new ElectricResistivity(nanoohmmeters, ElectricResistivityUnit.NanoohmMeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.NanoohmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.OhmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromOhmsCentimeter(double ohmscentimeter)
+        public static ElectricResistivity FromOhmsCentimeter(double value)
         {
-            return new ElectricResistivity(ohmscentimeter, ElectricResistivityUnit.OhmCentimeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.OhmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.OhmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromOhmMeters(double ohmmeters)
+        public static ElectricResistivity FromOhmMeters(double value)
         {
-            return new ElectricResistivity(ohmmeters, ElectricResistivityUnit.OhmMeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.OhmMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.PicoohmCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromPicoohmsCentimeter(double picoohmscentimeter)
+        public static ElectricResistivity FromPicoohmsCentimeter(double value)
         {
-            return new ElectricResistivity(picoohmscentimeter, ElectricResistivityUnit.PicoohmCentimeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricResistivity"/> from <see cref="ElectricResistivityUnit.PicoohmMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricResistivity FromPicoohmMeters(double picoohmmeters)
+        public static ElectricResistivity FromPicoohmMeters(double value)
         {
-            return new ElectricResistivity(picoohmmeters, ElectricResistivityUnit.PicoohmMeter);
+            return new ElectricResistivity(value, ElectricResistivityUnit.PicoohmMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
index 0100afc14f..5e34876016 100644
--- a/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ElectricSurfaceChargeDensity.g.cs
@@ -240,27 +240,27 @@ public static string GetAbbreviation(ElectricSurfaceChargeDensityUnit unit, IFor
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(double coulombspersquarecentimeter)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareCentimeter(double value)
         {
-            return new ElectricSurfaceChargeDensity(coulombspersquarecentimeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
+            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(double coulombspersquareinch)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareInch(double value)
         {
-            return new ElectricSurfaceChargeDensity(coulombspersquareinch, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
+            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ElectricSurfaceChargeDensity"/> from <see cref="ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(double coulombspersquaremeter)
+        public static ElectricSurfaceChargeDensity FromCoulombsPerSquareMeter(double value)
         {
-            return new ElectricSurfaceChargeDensity(coulombspersquaremeter, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
+            return new ElectricSurfaceChargeDensity(value, ElectricSurfaceChargeDensityUnit.CoulombPerSquareMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
index b0dc36db32..398081c271 100644
--- a/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Energy.g.cs
@@ -548,360 +548,360 @@ public static string GetAbbreviation(EnergyUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.BritishThermalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromBritishThermalUnits(double britishthermalunits)
+        public static Energy FromBritishThermalUnits(double value)
         {
-            return new Energy(britishthermalunits, EnergyUnit.BritishThermalUnit);
+            return new Energy(value, EnergyUnit.BritishThermalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Calorie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromCalories(double calories)
+        public static Energy FromCalories(double value)
         {
-            return new Energy(calories, EnergyUnit.Calorie);
+            return new Energy(value, EnergyUnit.Calorie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermEc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsEc(double decathermsec)
+        public static Energy FromDecathermsEc(double value)
         {
-            return new Energy(decathermsec, EnergyUnit.DecathermEc);
+            return new Energy(value, EnergyUnit.DecathermEc);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermImperial"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsImperial(double decathermsimperial)
+        public static Energy FromDecathermsImperial(double value)
         {
-            return new Energy(decathermsimperial, EnergyUnit.DecathermImperial);
+            return new Energy(value, EnergyUnit.DecathermImperial);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.DecathermUs"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromDecathermsUs(double decathermsus)
+        public static Energy FromDecathermsUs(double value)
         {
-            return new Energy(decathermsus, EnergyUnit.DecathermUs);
+            return new Energy(value, EnergyUnit.DecathermUs);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ElectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromElectronVolts(double electronvolts)
+        public static Energy FromElectronVolts(double value)
         {
-            return new Energy(electronvolts, EnergyUnit.ElectronVolt);
+            return new Energy(value, EnergyUnit.ElectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Erg"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromErgs(double ergs)
+        public static Energy FromErgs(double value)
         {
-            return new Energy(ergs, EnergyUnit.Erg);
+            return new Energy(value, EnergyUnit.Erg);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.FootPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromFootPounds(double footpounds)
+        public static Energy FromFootPounds(double value)
         {
-            return new Energy(footpounds, EnergyUnit.FootPound);
+            return new Energy(value, EnergyUnit.FootPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigabritishThermalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigabritishThermalUnits(double gigabritishthermalunits)
+        public static Energy FromGigabritishThermalUnits(double value)
         {
-            return new Energy(gigabritishthermalunits, EnergyUnit.GigabritishThermalUnit);
+            return new Energy(value, EnergyUnit.GigabritishThermalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigaelectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigaelectronVolts(double gigaelectronvolts)
+        public static Energy FromGigaelectronVolts(double value)
         {
-            return new Energy(gigaelectronvolts, EnergyUnit.GigaelectronVolt);
+            return new Energy(value, EnergyUnit.GigaelectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Gigajoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigajoules(double gigajoules)
+        public static Energy FromGigajoules(double value)
         {
-            return new Energy(gigajoules, EnergyUnit.Gigajoule);
+            return new Energy(value, EnergyUnit.Gigajoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigawattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigawattDays(double gigawattdays)
+        public static Energy FromGigawattDays(double value)
         {
-            return new Energy(gigawattdays, EnergyUnit.GigawattDay);
+            return new Energy(value, EnergyUnit.GigawattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.GigawattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromGigawattHours(double gigawatthours)
+        public static Energy FromGigawattHours(double value)
         {
-            return new Energy(gigawatthours, EnergyUnit.GigawattHour);
+            return new Energy(value, EnergyUnit.GigawattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.HorsepowerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromHorsepowerHours(double horsepowerhours)
+        public static Energy FromHorsepowerHours(double value)
         {
-            return new Energy(horsepowerhours, EnergyUnit.HorsepowerHour);
+            return new Energy(value, EnergyUnit.HorsepowerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Joule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromJoules(double joules)
+        public static Energy FromJoules(double value)
         {
-            return new Energy(joules, EnergyUnit.Joule);
+            return new Energy(value, EnergyUnit.Joule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilobritishThermalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilobritishThermalUnits(double kilobritishthermalunits)
+        public static Energy FromKilobritishThermalUnits(double value)
         {
-            return new Energy(kilobritishthermalunits, EnergyUnit.KilobritishThermalUnit);
+            return new Energy(value, EnergyUnit.KilobritishThermalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Kilocalorie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilocalories(double kilocalories)
+        public static Energy FromKilocalories(double value)
         {
-            return new Energy(kilocalories, EnergyUnit.Kilocalorie);
+            return new Energy(value, EnergyUnit.Kilocalorie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KiloelectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKiloelectronVolts(double kiloelectronvolts)
+        public static Energy FromKiloelectronVolts(double value)
         {
-            return new Energy(kiloelectronvolts, EnergyUnit.KiloelectronVolt);
+            return new Energy(value, EnergyUnit.KiloelectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Kilojoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilojoules(double kilojoules)
+        public static Energy FromKilojoules(double value)
         {
-            return new Energy(kilojoules, EnergyUnit.Kilojoule);
+            return new Energy(value, EnergyUnit.Kilojoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilowattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilowattDays(double kilowattdays)
+        public static Energy FromKilowattDays(double value)
         {
-            return new Energy(kilowattdays, EnergyUnit.KilowattDay);
+            return new Energy(value, EnergyUnit.KilowattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.KilowattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromKilowattHours(double kilowatthours)
+        public static Energy FromKilowattHours(double value)
         {
-            return new Energy(kilowatthours, EnergyUnit.KilowattHour);
+            return new Energy(value, EnergyUnit.KilowattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegabritishThermalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegabritishThermalUnits(double megabritishthermalunits)
+        public static Energy FromMegabritishThermalUnits(double value)
         {
-            return new Energy(megabritishthermalunits, EnergyUnit.MegabritishThermalUnit);
+            return new Energy(value, EnergyUnit.MegabritishThermalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Megacalorie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegacalories(double megacalories)
+        public static Energy FromMegacalories(double value)
         {
-            return new Energy(megacalories, EnergyUnit.Megacalorie);
+            return new Energy(value, EnergyUnit.Megacalorie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegaelectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegaelectronVolts(double megaelectronvolts)
+        public static Energy FromMegaelectronVolts(double value)
         {
-            return new Energy(megaelectronvolts, EnergyUnit.MegaelectronVolt);
+            return new Energy(value, EnergyUnit.MegaelectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Megajoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegajoules(double megajoules)
+        public static Energy FromMegajoules(double value)
         {
-            return new Energy(megajoules, EnergyUnit.Megajoule);
+            return new Energy(value, EnergyUnit.Megajoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegawattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegawattDays(double megawattdays)
+        public static Energy FromMegawattDays(double value)
         {
-            return new Energy(megawattdays, EnergyUnit.MegawattDay);
+            return new Energy(value, EnergyUnit.MegawattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.MegawattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMegawattHours(double megawatthours)
+        public static Energy FromMegawattHours(double value)
         {
-            return new Energy(megawatthours, EnergyUnit.MegawattHour);
+            return new Energy(value, EnergyUnit.MegawattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Microjoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMicrojoules(double microjoules)
+        public static Energy FromMicrojoules(double value)
         {
-            return new Energy(microjoules, EnergyUnit.Microjoule);
+            return new Energy(value, EnergyUnit.Microjoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Millijoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromMillijoules(double millijoules)
+        public static Energy FromMillijoules(double value)
         {
-            return new Energy(millijoules, EnergyUnit.Millijoule);
+            return new Energy(value, EnergyUnit.Millijoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Nanojoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromNanojoules(double nanojoules)
+        public static Energy FromNanojoules(double value)
         {
-            return new Energy(nanojoules, EnergyUnit.Nanojoule);
+            return new Energy(value, EnergyUnit.Nanojoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Petajoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromPetajoules(double petajoules)
+        public static Energy FromPetajoules(double value)
         {
-            return new Energy(petajoules, EnergyUnit.Petajoule);
+            return new Energy(value, EnergyUnit.Petajoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TeraelectronVolt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTeraelectronVolts(double teraelectronvolts)
+        public static Energy FromTeraelectronVolts(double value)
         {
-            return new Energy(teraelectronvolts, EnergyUnit.TeraelectronVolt);
+            return new Energy(value, EnergyUnit.TeraelectronVolt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.Terajoule"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTerajoules(double terajoules)
+        public static Energy FromTerajoules(double value)
         {
-            return new Energy(terajoules, EnergyUnit.Terajoule);
+            return new Energy(value, EnergyUnit.Terajoule);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TerawattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTerawattDays(double terawattdays)
+        public static Energy FromTerawattDays(double value)
         {
-            return new Energy(terawattdays, EnergyUnit.TerawattDay);
+            return new Energy(value, EnergyUnit.TerawattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.TerawattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromTerawattHours(double terawatthours)
+        public static Energy FromTerawattHours(double value)
         {
-            return new Energy(terawatthours, EnergyUnit.TerawattHour);
+            return new Energy(value, EnergyUnit.TerawattHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermEc"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsEc(double thermsec)
+        public static Energy FromThermsEc(double value)
         {
-            return new Energy(thermsec, EnergyUnit.ThermEc);
+            return new Energy(value, EnergyUnit.ThermEc);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermImperial"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsImperial(double thermsimperial)
+        public static Energy FromThermsImperial(double value)
         {
-            return new Energy(thermsimperial, EnergyUnit.ThermImperial);
+            return new Energy(value, EnergyUnit.ThermImperial);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.ThermUs"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromThermsUs(double thermsus)
+        public static Energy FromThermsUs(double value)
         {
-            return new Energy(thermsus, EnergyUnit.ThermUs);
+            return new Energy(value, EnergyUnit.ThermUs);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.WattDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromWattDays(double wattdays)
+        public static Energy FromWattDays(double value)
         {
-            return new Energy(wattdays, EnergyUnit.WattDay);
+            return new Energy(value, EnergyUnit.WattDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="Energy"/> from <see cref="EnergyUnit.WattHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Energy FromWattHours(double watthours)
+        public static Energy FromWattHours(double value)
         {
-            return new Energy(watthours, EnergyUnit.WattHour);
+            return new Energy(value, EnergyUnit.WattHour);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
index da6aa0ead8..b9b53f8fee 100644
--- a/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/EnergyDensity.g.cs
@@ -315,108 +315,108 @@ public static string GetAbbreviation(EnergyDensityUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.GigajoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromGigajoulesPerCubicMeter(double gigajoulespercubicmeter)
+        public static EnergyDensity FromGigajoulesPerCubicMeter(double value)
         {
-            return new EnergyDensity(gigajoulespercubicmeter, EnergyDensityUnit.GigajoulePerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.GigajoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.GigawattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromGigawattHoursPerCubicMeter(double gigawatthourspercubicmeter)
+        public static EnergyDensity FromGigawattHoursPerCubicMeter(double value)
         {
-            return new EnergyDensity(gigawatthourspercubicmeter, EnergyDensityUnit.GigawattHourPerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.GigawattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.JoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromJoulesPerCubicMeter(double joulespercubicmeter)
+        public static EnergyDensity FromJoulesPerCubicMeter(double value)
         {
-            return new EnergyDensity(joulespercubicmeter, EnergyDensityUnit.JoulePerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.JoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.KilojoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromKilojoulesPerCubicMeter(double kilojoulespercubicmeter)
+        public static EnergyDensity FromKilojoulesPerCubicMeter(double value)
         {
-            return new EnergyDensity(kilojoulespercubicmeter, EnergyDensityUnit.KilojoulePerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.KilojoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.KilowattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromKilowattHoursPerCubicMeter(double kilowatthourspercubicmeter)
+        public static EnergyDensity FromKilowattHoursPerCubicMeter(double value)
         {
-            return new EnergyDensity(kilowatthourspercubicmeter, EnergyDensityUnit.KilowattHourPerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.KilowattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.MegajoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromMegajoulesPerCubicMeter(double megajoulespercubicmeter)
+        public static EnergyDensity FromMegajoulesPerCubicMeter(double value)
         {
-            return new EnergyDensity(megajoulespercubicmeter, EnergyDensityUnit.MegajoulePerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.MegajoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.MegawattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromMegawattHoursPerCubicMeter(double megawatthourspercubicmeter)
+        public static EnergyDensity FromMegawattHoursPerCubicMeter(double value)
         {
-            return new EnergyDensity(megawatthourspercubicmeter, EnergyDensityUnit.MegawattHourPerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.MegawattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.PetajoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromPetajoulesPerCubicMeter(double petajoulespercubicmeter)
+        public static EnergyDensity FromPetajoulesPerCubicMeter(double value)
         {
-            return new EnergyDensity(petajoulespercubicmeter, EnergyDensityUnit.PetajoulePerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.PetajoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.PetawattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromPetawattHoursPerCubicMeter(double petawatthourspercubicmeter)
+        public static EnergyDensity FromPetawattHoursPerCubicMeter(double value)
         {
-            return new EnergyDensity(petawatthourspercubicmeter, EnergyDensityUnit.PetawattHourPerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.PetawattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.TerajoulePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromTerajoulesPerCubicMeter(double terajoulespercubicmeter)
+        public static EnergyDensity FromTerajoulesPerCubicMeter(double value)
         {
-            return new EnergyDensity(terajoulespercubicmeter, EnergyDensityUnit.TerajoulePerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.TerajoulePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.TerawattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromTerawattHoursPerCubicMeter(double terawatthourspercubicmeter)
+        public static EnergyDensity FromTerawattHoursPerCubicMeter(double value)
         {
-            return new EnergyDensity(terawatthourspercubicmeter, EnergyDensityUnit.TerawattHourPerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.TerawattHourPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="EnergyDensity"/> from <see cref="EnergyDensityUnit.WattHourPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static EnergyDensity FromWattHoursPerCubicMeter(double watthourspercubicmeter)
+        public static EnergyDensity FromWattHoursPerCubicMeter(double value)
         {
-            return new EnergyDensity(watthourspercubicmeter, EnergyDensityUnit.WattHourPerCubicMeter);
+            return new EnergyDensity(value, EnergyDensityUnit.WattHourPerCubicMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
index 53677dec17..179ae809d3 100644
--- a/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Entropy.g.cs
@@ -276,63 +276,63 @@ public static string GetAbbreviation(EntropyUnit unit, IFormatProvider? provider
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.CaloriePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromCaloriesPerKelvin(double caloriesperkelvin)
+        public static Entropy FromCaloriesPerKelvin(double value)
         {
-            return new Entropy(caloriesperkelvin, EntropyUnit.CaloriePerKelvin);
+            return new Entropy(value, EntropyUnit.CaloriePerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.JoulePerDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromJoulesPerDegreeCelsius(double joulesperdegreecelsius)
+        public static Entropy FromJoulesPerDegreeCelsius(double value)
         {
-            return new Entropy(joulesperdegreecelsius, EntropyUnit.JoulePerDegreeCelsius);
+            return new Entropy(value, EntropyUnit.JoulePerDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.JoulePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromJoulesPerKelvin(double joulesperkelvin)
+        public static Entropy FromJoulesPerKelvin(double value)
         {
-            return new Entropy(joulesperkelvin, EntropyUnit.JoulePerKelvin);
+            return new Entropy(value, EntropyUnit.JoulePerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilocaloriePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilocaloriesPerKelvin(double kilocaloriesperkelvin)
+        public static Entropy FromKilocaloriesPerKelvin(double value)
         {
-            return new Entropy(kilocaloriesperkelvin, EntropyUnit.KilocaloriePerKelvin);
+            return new Entropy(value, EntropyUnit.KilocaloriePerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilojoulePerDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilojoulesPerDegreeCelsius(double kilojoulesperdegreecelsius)
+        public static Entropy FromKilojoulesPerDegreeCelsius(double value)
         {
-            return new Entropy(kilojoulesperdegreecelsius, EntropyUnit.KilojoulePerDegreeCelsius);
+            return new Entropy(value, EntropyUnit.KilojoulePerDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.KilojoulePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromKilojoulesPerKelvin(double kilojoulesperkelvin)
+        public static Entropy FromKilojoulesPerKelvin(double value)
         {
-            return new Entropy(kilojoulesperkelvin, EntropyUnit.KilojoulePerKelvin);
+            return new Entropy(value, EntropyUnit.KilojoulePerKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Entropy"/> from <see cref="EntropyUnit.MegajoulePerKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Entropy FromMegajoulesPerKelvin(double megajoulesperkelvin)
+        public static Entropy FromMegajoulesPerKelvin(double value)
         {
-            return new Entropy(megajoulesperkelvin, EntropyUnit.MegajoulePerKelvin);
+            return new Entropy(value, EntropyUnit.MegajoulePerKelvin);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
index 8e0d17e118..7589bb7e99 100644
--- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
@@ -348,135 +348,135 @@ public static string GetAbbreviation(ForceUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Decanewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromDecanewtons(double decanewtons)
+        public static Force FromDecanewtons(double value)
         {
-            return new Force(decanewtons, ForceUnit.Decanewton);
+            return new Force(value, ForceUnit.Decanewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Dyn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromDyne(double dyne)
+        public static Force FromDyne(double value)
         {
-            return new Force(dyne, ForceUnit.Dyn);
+            return new Force(value, ForceUnit.Dyn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KilogramForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilogramsForce(double kilogramsforce)
+        public static Force FromKilogramsForce(double value)
         {
-            return new Force(kilogramsforce, ForceUnit.KilogramForce);
+            return new Force(value, ForceUnit.KilogramForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Kilonewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilonewtons(double kilonewtons)
+        public static Force FromKilonewtons(double value)
         {
-            return new Force(kilonewtons, ForceUnit.Kilonewton);
+            return new Force(value, ForceUnit.Kilonewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KiloPond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKiloPonds(double kiloponds)
+        public static Force FromKiloPonds(double value)
         {
-            return new Force(kiloponds, ForceUnit.KiloPond);
+            return new Force(value, ForceUnit.KiloPond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.KilopoundForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromKilopoundsForce(double kilopoundsforce)
+        public static Force FromKilopoundsForce(double value)
         {
-            return new Force(kilopoundsforce, ForceUnit.KilopoundForce);
+            return new Force(value, ForceUnit.KilopoundForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Meganewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMeganewtons(double meganewtons)
+        public static Force FromMeganewtons(double value)
         {
-            return new Force(meganewtons, ForceUnit.Meganewton);
+            return new Force(value, ForceUnit.Meganewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Micronewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMicronewtons(double micronewtons)
+        public static Force FromMicronewtons(double value)
         {
-            return new Force(micronewtons, ForceUnit.Micronewton);
+            return new Force(value, ForceUnit.Micronewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Millinewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromMillinewtons(double millinewtons)
+        public static Force FromMillinewtons(double value)
         {
-            return new Force(millinewtons, ForceUnit.Millinewton);
+            return new Force(value, ForceUnit.Millinewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Newton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromNewtons(double newtons)
+        public static Force FromNewtons(double value)
         {
-            return new Force(newtons, ForceUnit.Newton);
+            return new Force(value, ForceUnit.Newton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.OunceForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromOunceForce(double ounceforce)
+        public static Force FromOunceForce(double value)
         {
-            return new Force(ounceforce, ForceUnit.OunceForce);
+            return new Force(value, ForceUnit.OunceForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.Poundal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromPoundals(double poundals)
+        public static Force FromPoundals(double value)
         {
-            return new Force(poundals, ForceUnit.Poundal);
+            return new Force(value, ForceUnit.Poundal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.PoundForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromPoundsForce(double poundsforce)
+        public static Force FromPoundsForce(double value)
         {
-            return new Force(poundsforce, ForceUnit.PoundForce);
+            return new Force(value, ForceUnit.PoundForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.ShortTonForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromShortTonsForce(double shorttonsforce)
+        public static Force FromShortTonsForce(double value)
         {
-            return new Force(shorttonsforce, ForceUnit.ShortTonForce);
+            return new Force(value, ForceUnit.ShortTonForce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Force"/> from <see cref="ForceUnit.TonneForce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Force FromTonnesForce(double tonnesforce)
+        public static Force FromTonnesForce(double value)
         {
-            return new Force(tonnesforce, ForceUnit.TonneForce);
+            return new Force(value, ForceUnit.TonneForce);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
index 63b0c2a3cc..7e45485779 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForceChangeRate.g.cs
@@ -340,135 +340,135 @@ public static string GetAbbreviation(ForceChangeRateUnit unit, IFormatProvider?
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.CentinewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromCentinewtonsPerSecond(double centinewtonspersecond)
+        public static ForceChangeRate FromCentinewtonsPerSecond(double value)
         {
-            return new ForceChangeRate(centinewtonspersecond, ForceChangeRateUnit.CentinewtonPerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.CentinewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecanewtonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecanewtonsPerMinute(double decanewtonsperminute)
+        public static ForceChangeRate FromDecanewtonsPerMinute(double value)
         {
-            return new ForceChangeRate(decanewtonsperminute, ForceChangeRateUnit.DecanewtonPerMinute);
+            return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecanewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecanewtonsPerSecond(double decanewtonspersecond)
+        public static ForceChangeRate FromDecanewtonsPerSecond(double value)
         {
-            return new ForceChangeRate(decanewtonspersecond, ForceChangeRateUnit.DecanewtonPerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.DecanewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.DecinewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromDecinewtonsPerSecond(double decinewtonspersecond)
+        public static ForceChangeRate FromDecinewtonsPerSecond(double value)
         {
-            return new ForceChangeRate(decinewtonspersecond, ForceChangeRateUnit.DecinewtonPerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.DecinewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilonewtonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilonewtonsPerMinute(double kilonewtonsperminute)
+        public static ForceChangeRate FromKilonewtonsPerMinute(double value)
         {
-            return new ForceChangeRate(kilonewtonsperminute, ForceChangeRateUnit.KilonewtonPerMinute);
+            return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilonewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilonewtonsPerSecond(double kilonewtonspersecond)
+        public static ForceChangeRate FromKilonewtonsPerSecond(double value)
         {
-            return new ForceChangeRate(kilonewtonspersecond, ForceChangeRateUnit.KilonewtonPerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.KilonewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilopoundForcePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilopoundsForcePerMinute(double kilopoundsforceperminute)
+        public static ForceChangeRate FromKilopoundsForcePerMinute(double value)
         {
-            return new ForceChangeRate(kilopoundsforceperminute, ForceChangeRateUnit.KilopoundForcePerMinute);
+            return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.KilopoundForcePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromKilopoundsForcePerSecond(double kilopoundsforcepersecond)
+        public static ForceChangeRate FromKilopoundsForcePerSecond(double value)
         {
-            return new ForceChangeRate(kilopoundsforcepersecond, ForceChangeRateUnit.KilopoundForcePerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.KilopoundForcePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.MicronewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromMicronewtonsPerSecond(double micronewtonspersecond)
+        public static ForceChangeRate FromMicronewtonsPerSecond(double value)
         {
-            return new ForceChangeRate(micronewtonspersecond, ForceChangeRateUnit.MicronewtonPerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.MicronewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.MillinewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromMillinewtonsPerSecond(double millinewtonspersecond)
+        public static ForceChangeRate FromMillinewtonsPerSecond(double value)
         {
-            return new ForceChangeRate(millinewtonspersecond, ForceChangeRateUnit.MillinewtonPerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.MillinewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NanonewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNanonewtonsPerSecond(double nanonewtonspersecond)
+        public static ForceChangeRate FromNanonewtonsPerSecond(double value)
         {
-            return new ForceChangeRate(nanonewtonspersecond, ForceChangeRateUnit.NanonewtonPerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.NanonewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NewtonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNewtonsPerMinute(double newtonsperminute)
+        public static ForceChangeRate FromNewtonsPerMinute(double value)
         {
-            return new ForceChangeRate(newtonsperminute, ForceChangeRateUnit.NewtonPerMinute);
+            return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.NewtonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromNewtonsPerSecond(double newtonspersecond)
+        public static ForceChangeRate FromNewtonsPerSecond(double value)
         {
-            return new ForceChangeRate(newtonspersecond, ForceChangeRateUnit.NewtonPerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.NewtonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.PoundForcePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromPoundsForcePerMinute(double poundsforceperminute)
+        public static ForceChangeRate FromPoundsForcePerMinute(double value)
         {
-            return new ForceChangeRate(poundsforceperminute, ForceChangeRateUnit.PoundForcePerMinute);
+            return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForceChangeRate"/> from <see cref="ForceChangeRateUnit.PoundForcePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForceChangeRate FromPoundsForcePerSecond(double poundsforcepersecond)
+        public static ForceChangeRate FromPoundsForcePerSecond(double value)
         {
-            return new ForceChangeRate(poundsforcepersecond, ForceChangeRateUnit.PoundForcePerSecond);
+            return new ForceChangeRate(value, ForceChangeRateUnit.PoundForcePerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
index ccb2a8f698..a03cd01f8a 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
@@ -527,342 +527,342 @@ public static string GetAbbreviation(ForcePerLengthUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerCentimeter(double centinewtonspercentimeter)
+        public static ForcePerLength FromCentinewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(centinewtonspercentimeter, ForcePerLengthUnit.CentinewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerMeter(double centinewtonspermeter)
+        public static ForcePerLength FromCentinewtonsPerMeter(double value)
         {
-            return new ForcePerLength(centinewtonspermeter, ForcePerLengthUnit.CentinewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.CentinewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromCentinewtonsPerMillimeter(double centinewtonspermillimeter)
+        public static ForcePerLength FromCentinewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(centinewtonspermillimeter, ForcePerLengthUnit.CentinewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.CentinewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerCentimeter(double decanewtonspercentimeter)
+        public static ForcePerLength FromDecanewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(decanewtonspercentimeter, ForcePerLengthUnit.DecanewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerMeter(double decanewtonspermeter)
+        public static ForcePerLength FromDecanewtonsPerMeter(double value)
         {
-            return new ForcePerLength(decanewtonspermeter, ForcePerLengthUnit.DecanewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecanewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecanewtonsPerMillimeter(double decanewtonspermillimeter)
+        public static ForcePerLength FromDecanewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(decanewtonspermillimeter, ForcePerLengthUnit.DecanewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.DecanewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerCentimeter(double decinewtonspercentimeter)
+        public static ForcePerLength FromDecinewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(decinewtonspercentimeter, ForcePerLengthUnit.DecinewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerMeter(double decinewtonspermeter)
+        public static ForcePerLength FromDecinewtonsPerMeter(double value)
         {
-            return new ForcePerLength(decinewtonspermeter, ForcePerLengthUnit.DecinewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.DecinewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromDecinewtonsPerMillimeter(double decinewtonspermillimeter)
+        public static ForcePerLength FromDecinewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(decinewtonspermillimeter, ForcePerLengthUnit.DecinewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.DecinewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerCentimeter(double kilogramsforcepercentimeter)
+        public static ForcePerLength FromKilogramsForcePerCentimeter(double value)
         {
-            return new ForcePerLength(kilogramsforcepercentimeter, ForcePerLengthUnit.KilogramForcePerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerMeter(double kilogramsforcepermeter)
+        public static ForcePerLength FromKilogramsForcePerMeter(double value)
         {
-            return new ForcePerLength(kilogramsforcepermeter, ForcePerLengthUnit.KilogramForcePerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilogramForcePerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilogramsForcePerMillimeter(double kilogramsforcepermillimeter)
+        public static ForcePerLength FromKilogramsForcePerMillimeter(double value)
         {
-            return new ForcePerLength(kilogramsforcepermillimeter, ForcePerLengthUnit.KilogramForcePerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.KilogramForcePerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerCentimeter(double kilonewtonspercentimeter)
+        public static ForcePerLength FromKilonewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(kilonewtonspercentimeter, ForcePerLengthUnit.KilonewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerMeter(double kilonewtonspermeter)
+        public static ForcePerLength FromKilonewtonsPerMeter(double value)
         {
-            return new ForcePerLength(kilonewtonspermeter, ForcePerLengthUnit.KilonewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilonewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilonewtonsPerMillimeter(double kilonewtonspermillimeter)
+        public static ForcePerLength FromKilonewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(kilonewtonspermillimeter, ForcePerLengthUnit.KilonewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.KilonewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilopoundForcePerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilopoundsForcePerFoot(double kilopoundsforceperfoot)
+        public static ForcePerLength FromKilopoundsForcePerFoot(double value)
         {
-            return new ForcePerLength(kilopoundsforceperfoot, ForcePerLengthUnit.KilopoundForcePerFoot);
+            return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.KilopoundForcePerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromKilopoundsForcePerInch(double kilopoundsforceperinch)
+        public static ForcePerLength FromKilopoundsForcePerInch(double value)
         {
-            return new ForcePerLength(kilopoundsforceperinch, ForcePerLengthUnit.KilopoundForcePerInch);
+            return new ForcePerLength(value, ForcePerLengthUnit.KilopoundForcePerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerCentimeter(double meganewtonspercentimeter)
+        public static ForcePerLength FromMeganewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(meganewtonspercentimeter, ForcePerLengthUnit.MeganewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerMeter(double meganewtonspermeter)
+        public static ForcePerLength FromMeganewtonsPerMeter(double value)
         {
-            return new ForcePerLength(meganewtonspermeter, ForcePerLengthUnit.MeganewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MeganewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMeganewtonsPerMillimeter(double meganewtonspermillimeter)
+        public static ForcePerLength FromMeganewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(meganewtonspermillimeter, ForcePerLengthUnit.MeganewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MeganewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerCentimeter(double micronewtonspercentimeter)
+        public static ForcePerLength FromMicronewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(micronewtonspercentimeter, ForcePerLengthUnit.MicronewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerMeter(double micronewtonspermeter)
+        public static ForcePerLength FromMicronewtonsPerMeter(double value)
         {
-            return new ForcePerLength(micronewtonspermeter, ForcePerLengthUnit.MicronewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MicronewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMicronewtonsPerMillimeter(double micronewtonspermillimeter)
+        public static ForcePerLength FromMicronewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(micronewtonspermillimeter, ForcePerLengthUnit.MicronewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MicronewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerCentimeter(double millinewtonspercentimeter)
+        public static ForcePerLength FromMillinewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(millinewtonspercentimeter, ForcePerLengthUnit.MillinewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerMeter(double millinewtonspermeter)
+        public static ForcePerLength FromMillinewtonsPerMeter(double value)
         {
-            return new ForcePerLength(millinewtonspermeter, ForcePerLengthUnit.MillinewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.MillinewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromMillinewtonsPerMillimeter(double millinewtonspermillimeter)
+        public static ForcePerLength FromMillinewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(millinewtonspermillimeter, ForcePerLengthUnit.MillinewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.MillinewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerCentimeter(double nanonewtonspercentimeter)
+        public static ForcePerLength FromNanonewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(nanonewtonspercentimeter, ForcePerLengthUnit.NanonewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerMeter(double nanonewtonspermeter)
+        public static ForcePerLength FromNanonewtonsPerMeter(double value)
         {
-            return new ForcePerLength(nanonewtonspermeter, ForcePerLengthUnit.NanonewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NanonewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNanonewtonsPerMillimeter(double nanonewtonspermillimeter)
+        public static ForcePerLength FromNanonewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(nanonewtonspermillimeter, ForcePerLengthUnit.NanonewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.NanonewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerCentimeter(double newtonspercentimeter)
+        public static ForcePerLength FromNewtonsPerCentimeter(double value)
         {
-            return new ForcePerLength(newtonspercentimeter, ForcePerLengthUnit.NewtonPerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerMeter(double newtonspermeter)
+        public static ForcePerLength FromNewtonsPerMeter(double value)
         {
-            return new ForcePerLength(newtonspermeter, ForcePerLengthUnit.NewtonPerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.NewtonPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromNewtonsPerMillimeter(double newtonspermillimeter)
+        public static ForcePerLength FromNewtonsPerMillimeter(double value)
         {
-            return new ForcePerLength(newtonspermillimeter, ForcePerLengthUnit.NewtonPerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.NewtonPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerFoot(double poundsforceperfoot)
+        public static ForcePerLength FromPoundsForcePerFoot(double value)
         {
-            return new ForcePerLength(poundsforceperfoot, ForcePerLengthUnit.PoundForcePerFoot);
+            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerInch(double poundsforceperinch)
+        public static ForcePerLength FromPoundsForcePerInch(double value)
         {
-            return new ForcePerLength(poundsforceperinch, ForcePerLengthUnit.PoundForcePerInch);
+            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.PoundForcePerYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromPoundsForcePerYard(double poundsforceperyard)
+        public static ForcePerLength FromPoundsForcePerYard(double value)
         {
-            return new ForcePerLength(poundsforceperyard, ForcePerLengthUnit.PoundForcePerYard);
+            return new ForcePerLength(value, ForcePerLengthUnit.PoundForcePerYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerCentimeter(double tonnesforcepercentimeter)
+        public static ForcePerLength FromTonnesForcePerCentimeter(double value)
         {
-            return new ForcePerLength(tonnesforcepercentimeter, ForcePerLengthUnit.TonneForcePerCentimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerMeter(double tonnesforcepermeter)
+        public static ForcePerLength FromTonnesForcePerMeter(double value)
         {
-            return new ForcePerLength(tonnesforcepermeter, ForcePerLengthUnit.TonneForcePerMeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ForcePerLength"/> from <see cref="ForcePerLengthUnit.TonneForcePerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ForcePerLength FromTonnesForcePerMillimeter(double tonnesforcepermillimeter)
+        public static ForcePerLength FromTonnesForcePerMillimeter(double value)
         {
-            return new ForcePerLength(tonnesforcepermillimeter, ForcePerLengthUnit.TonneForcePerMillimeter);
+            return new ForcePerLength(value, ForcePerLengthUnit.TonneForcePerMillimeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
index 49aa24a00a..475e716416 100644
--- a/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Frequency.g.cs
@@ -323,117 +323,117 @@ public static string GetAbbreviation(FrequencyUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.BeatPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromBeatsPerMinute(double beatsperminute)
+        public static Frequency FromBeatsPerMinute(double value)
         {
-            return new Frequency(beatsperminute, FrequencyUnit.BeatPerMinute);
+            return new Frequency(value, FrequencyUnit.BeatPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.BUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromBUnits(double bunits)
+        public static Frequency FromBUnits(double value)
         {
-            return new Frequency(bunits, FrequencyUnit.BUnit);
+            return new Frequency(value, FrequencyUnit.BUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.CyclePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromCyclesPerHour(double cyclesperhour)
+        public static Frequency FromCyclesPerHour(double value)
         {
-            return new Frequency(cyclesperhour, FrequencyUnit.CyclePerHour);
+            return new Frequency(value, FrequencyUnit.CyclePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.CyclePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromCyclesPerMinute(double cyclesperminute)
+        public static Frequency FromCyclesPerMinute(double value)
         {
-            return new Frequency(cyclesperminute, FrequencyUnit.CyclePerMinute);
+            return new Frequency(value, FrequencyUnit.CyclePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Gigahertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromGigahertz(double gigahertz)
+        public static Frequency FromGigahertz(double value)
         {
-            return new Frequency(gigahertz, FrequencyUnit.Gigahertz);
+            return new Frequency(value, FrequencyUnit.Gigahertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Hertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromHertz(double hertz)
+        public static Frequency FromHertz(double value)
         {
-            return new Frequency(hertz, FrequencyUnit.Hertz);
+            return new Frequency(value, FrequencyUnit.Hertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Kilohertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromKilohertz(double kilohertz)
+        public static Frequency FromKilohertz(double value)
         {
-            return new Frequency(kilohertz, FrequencyUnit.Kilohertz);
+            return new Frequency(value, FrequencyUnit.Kilohertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Megahertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromMegahertz(double megahertz)
+        public static Frequency FromMegahertz(double value)
         {
-            return new Frequency(megahertz, FrequencyUnit.Megahertz);
+            return new Frequency(value, FrequencyUnit.Megahertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Microhertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromMicrohertz(double microhertz)
+        public static Frequency FromMicrohertz(double value)
         {
-            return new Frequency(microhertz, FrequencyUnit.Microhertz);
+            return new Frequency(value, FrequencyUnit.Microhertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Millihertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromMillihertz(double millihertz)
+        public static Frequency FromMillihertz(double value)
         {
-            return new Frequency(millihertz, FrequencyUnit.Millihertz);
+            return new Frequency(value, FrequencyUnit.Millihertz);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.PerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromPerSecond(double persecond)
+        public static Frequency FromPerSecond(double value)
         {
-            return new Frequency(persecond, FrequencyUnit.PerSecond);
+            return new Frequency(value, FrequencyUnit.PerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.RadianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromRadiansPerSecond(double radianspersecond)
+        public static Frequency FromRadiansPerSecond(double value)
         {
-            return new Frequency(radianspersecond, FrequencyUnit.RadianPerSecond);
+            return new Frequency(value, FrequencyUnit.RadianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Frequency"/> from <see cref="FrequencyUnit.Terahertz"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Frequency FromTerahertz(double terahertz)
+        public static Frequency FromTerahertz(double value)
         {
-            return new Frequency(terahertz, FrequencyUnit.Terahertz);
+            return new Frequency(value, FrequencyUnit.Terahertz);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
index cd57722a34..66a00f14f6 100644
--- a/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/FuelEfficiency.g.cs
@@ -248,36 +248,36 @@ public static string GetAbbreviation(FuelEfficiencyUnit unit, IFormatProvider? p
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.KilometerPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromKilometersPerLiter(double kilometersperliter)
+        public static FuelEfficiency FromKilometersPerLiter(double value)
         {
-            return new FuelEfficiency(kilometersperliter, FuelEfficiencyUnit.KilometerPerLiter);
+            return new FuelEfficiency(value, FuelEfficiencyUnit.KilometerPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.LiterPer100Kilometers"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromLitersPer100Kilometers(double litersper100kilometers)
+        public static FuelEfficiency FromLitersPer100Kilometers(double value)
         {
-            return new FuelEfficiency(litersper100kilometers, FuelEfficiencyUnit.LiterPer100Kilometers);
+            return new FuelEfficiency(value, FuelEfficiencyUnit.LiterPer100Kilometers);
         }
 
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.MilePerUkGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromMilesPerUkGallon(double milesperukgallon)
+        public static FuelEfficiency FromMilesPerUkGallon(double value)
         {
-            return new FuelEfficiency(milesperukgallon, FuelEfficiencyUnit.MilePerUkGallon);
+            return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUkGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="FuelEfficiency"/> from <see cref="FuelEfficiencyUnit.MilePerUsGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static FuelEfficiency FromMilesPerUsGallon(double milesperusgallon)
+        public static FuelEfficiency FromMilesPerUsGallon(double value)
         {
-            return new FuelEfficiency(milesperusgallon, FuelEfficiencyUnit.MilePerUsGallon);
+            return new FuelEfficiency(value, FuelEfficiencyUnit.MilePerUsGallon);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
index 577af9701d..6a31f77be8 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatFlux.g.cs
@@ -363,162 +363,162 @@ public static string GetAbbreviation(HeatFluxUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerHourSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerHourSquareFoot(double btusperhoursquarefoot)
+        public static HeatFlux FromBtusPerHourSquareFoot(double value)
         {
-            return new HeatFlux(btusperhoursquarefoot, HeatFluxUnit.BtuPerHourSquareFoot);
+            return new HeatFlux(value, HeatFluxUnit.BtuPerHourSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerMinuteSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerMinuteSquareFoot(double btusperminutesquarefoot)
+        public static HeatFlux FromBtusPerMinuteSquareFoot(double value)
         {
-            return new HeatFlux(btusperminutesquarefoot, HeatFluxUnit.BtuPerMinuteSquareFoot);
+            return new HeatFlux(value, HeatFluxUnit.BtuPerMinuteSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerSecondSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerSecondSquareFoot(double btuspersecondsquarefoot)
+        public static HeatFlux FromBtusPerSecondSquareFoot(double value)
         {
-            return new HeatFlux(btuspersecondsquarefoot, HeatFluxUnit.BtuPerSecondSquareFoot);
+            return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.BtuPerSecondSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromBtusPerSecondSquareInch(double btuspersecondsquareinch)
+        public static HeatFlux FromBtusPerSecondSquareInch(double value)
         {
-            return new HeatFlux(btuspersecondsquareinch, HeatFluxUnit.BtuPerSecondSquareInch);
+            return new HeatFlux(value, HeatFluxUnit.BtuPerSecondSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CaloriePerSecondSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromCaloriesPerSecondSquareCentimeter(double caloriespersecondsquarecentimeter)
+        public static HeatFlux FromCaloriesPerSecondSquareCentimeter(double value)
         {
-            return new HeatFlux(caloriespersecondsquarecentimeter, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
+            return new HeatFlux(value, HeatFluxUnit.CaloriePerSecondSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.CentiwattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromCentiwattsPerSquareMeter(double centiwattspersquaremeter)
+        public static HeatFlux FromCentiwattsPerSquareMeter(double value)
         {
-            return new HeatFlux(centiwattspersquaremeter, HeatFluxUnit.CentiwattPerSquareMeter);
+            return new HeatFlux(value, HeatFluxUnit.CentiwattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.DeciwattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromDeciwattsPerSquareMeter(double deciwattspersquaremeter)
+        public static HeatFlux FromDeciwattsPerSquareMeter(double value)
         {
-            return new HeatFlux(deciwattspersquaremeter, HeatFluxUnit.DeciwattPerSquareMeter);
+            return new HeatFlux(value, HeatFluxUnit.DeciwattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilocaloriePerHourSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilocaloriesPerHourSquareMeter(double kilocaloriesperhoursquaremeter)
+        public static HeatFlux FromKilocaloriesPerHourSquareMeter(double value)
         {
-            return new HeatFlux(kilocaloriesperhoursquaremeter, HeatFluxUnit.KilocaloriePerHourSquareMeter);
+            return new HeatFlux(value, HeatFluxUnit.KilocaloriePerHourSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilocaloriePerSecondSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(double kilocaloriespersecondsquarecentimeter)
+        public static HeatFlux FromKilocaloriesPerSecondSquareCentimeter(double value)
         {
-            return new HeatFlux(kilocaloriespersecondsquarecentimeter, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
+            return new HeatFlux(value, HeatFluxUnit.KilocaloriePerSecondSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.KilowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromKilowattsPerSquareMeter(double kilowattspersquaremeter)
+        public static HeatFlux FromKilowattsPerSquareMeter(double value)
         {
-            return new HeatFlux(kilowattspersquaremeter, HeatFluxUnit.KilowattPerSquareMeter);
+            return new HeatFlux(value, HeatFluxUnit.KilowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MicrowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromMicrowattsPerSquareMeter(double microwattspersquaremeter)
+        public static HeatFlux FromMicrowattsPerSquareMeter(double value)
         {
-            return new HeatFlux(microwattspersquaremeter, HeatFluxUnit.MicrowattPerSquareMeter);
+            return new HeatFlux(value, HeatFluxUnit.MicrowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.MilliwattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromMilliwattsPerSquareMeter(double milliwattspersquaremeter)
+        public static HeatFlux FromMilliwattsPerSquareMeter(double value)
         {
-            return new HeatFlux(milliwattspersquaremeter, HeatFluxUnit.MilliwattPerSquareMeter);
+            return new HeatFlux(value, HeatFluxUnit.MilliwattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.NanowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromNanowattsPerSquareMeter(double nanowattspersquaremeter)
+        public static HeatFlux FromNanowattsPerSquareMeter(double value)
         {
-            return new HeatFlux(nanowattspersquaremeter, HeatFluxUnit.NanowattPerSquareMeter);
+            return new HeatFlux(value, HeatFluxUnit.NanowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.PoundForcePerFootSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromPoundsForcePerFootSecond(double poundsforceperfootsecond)
+        public static HeatFlux FromPoundsForcePerFootSecond(double value)
         {
-            return new HeatFlux(poundsforceperfootsecond, HeatFluxUnit.PoundForcePerFootSecond);
+            return new HeatFlux(value, HeatFluxUnit.PoundForcePerFootSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.PoundPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromPoundsPerSecondCubed(double poundspersecondcubed)
+        public static HeatFlux FromPoundsPerSecondCubed(double value)
         {
-            return new HeatFlux(poundspersecondcubed, HeatFluxUnit.PoundPerSecondCubed);
+            return new HeatFlux(value, HeatFluxUnit.PoundPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareFoot(double wattspersquarefoot)
+        public static HeatFlux FromWattsPerSquareFoot(double value)
         {
-            return new HeatFlux(wattspersquarefoot, HeatFluxUnit.WattPerSquareFoot);
+            return new HeatFlux(value, HeatFluxUnit.WattPerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareInch(double wattspersquareinch)
+        public static HeatFlux FromWattsPerSquareInch(double value)
         {
-            return new HeatFlux(wattspersquareinch, HeatFluxUnit.WattPerSquareInch);
+            return new HeatFlux(value, HeatFluxUnit.WattPerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatFlux"/> from <see cref="HeatFluxUnit.WattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatFlux FromWattsPerSquareMeter(double wattspersquaremeter)
+        public static HeatFlux FromWattsPerSquareMeter(double value)
         {
-            return new HeatFlux(wattspersquaremeter, HeatFluxUnit.WattPerSquareMeter);
+            return new HeatFlux(value, HeatFluxUnit.WattPerSquareMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
index 1c8b3d95f0..3b594f1644 100644
--- a/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/HeatTransferCoefficient.g.cs
@@ -262,9 +262,9 @@ public static string GetAbbreviation(HeatTransferCoefficientUnit unit, IFormatPr
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(double btusperhoursquarefootdegreefahrenheit)
+        public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(double value)
         {
-            return new HeatTransferCoefficient(btusperhoursquarefootdegreefahrenheit, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
+            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerHourSquareFootDegreeFahrenheit);
         }
 
         /// <summary>
@@ -272,45 +272,45 @@ public static HeatTransferCoefficient FromBtusPerHourSquareFootDegreeFahrenheit(
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         [Obsolete("The name of this definition incorrectly omitted time as divisor, please use BtuPerHourSquareFootDegreeFahrenheit instead")]
-        public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(double btuspersquarefootdegreefahrenheit)
+        public static HeatTransferCoefficient FromBtusPerSquareFootDegreeFahrenheit(double value)
         {
-            return new HeatTransferCoefficient(btuspersquarefootdegreefahrenheit, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
+            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.BtuPerSquareFootDegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromCaloriesPerHourSquareMeterDegreeCelsius(double caloriesperhoursquaremeterdegreecelsius)
+        public static HeatTransferCoefficient FromCaloriesPerHourSquareMeterDegreeCelsius(double value)
         {
-            return new HeatTransferCoefficient(caloriesperhoursquaremeterdegreecelsius, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
+            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.CaloriePerHourSquareMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromKilocaloriesPerHourSquareMeterDegreeCelsius(double kilocaloriesperhoursquaremeterdegreecelsius)
+        public static HeatTransferCoefficient FromKilocaloriesPerHourSquareMeterDegreeCelsius(double value)
         {
-            return new HeatTransferCoefficient(kilocaloriesperhoursquaremeterdegreecelsius, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
+            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.KilocaloriePerHourSquareMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(double wattspersquaremetercelsius)
+        public static HeatTransferCoefficient FromWattsPerSquareMeterCelsius(double value)
         {
-            return new HeatTransferCoefficient(wattspersquaremetercelsius, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
+            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="HeatTransferCoefficient"/> from <see cref="HeatTransferCoefficientUnit.WattPerSquareMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(double wattspersquaremeterkelvin)
+        public static HeatTransferCoefficient FromWattsPerSquareMeterKelvin(double value)
         {
-            return new HeatTransferCoefficient(wattspersquaremeterkelvin, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
+            return new HeatTransferCoefficient(value, HeatTransferCoefficientUnit.WattPerSquareMeterKelvin);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
index c35b8a1fe1..d3ec835c8b 100644
--- a/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Illuminance.g.cs
@@ -248,36 +248,36 @@ public static string GetAbbreviation(IlluminanceUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Kilolux"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromKilolux(double kilolux)
+        public static Illuminance FromKilolux(double value)
         {
-            return new Illuminance(kilolux, IlluminanceUnit.Kilolux);
+            return new Illuminance(value, IlluminanceUnit.Kilolux);
         }
 
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Lux"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromLux(double lux)
+        public static Illuminance FromLux(double value)
         {
-            return new Illuminance(lux, IlluminanceUnit.Lux);
+            return new Illuminance(value, IlluminanceUnit.Lux);
         }
 
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Megalux"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromMegalux(double megalux)
+        public static Illuminance FromMegalux(double value)
         {
-            return new Illuminance(megalux, IlluminanceUnit.Megalux);
+            return new Illuminance(value, IlluminanceUnit.Megalux);
         }
 
         /// <summary>
         ///     Creates a <see cref="Illuminance"/> from <see cref="IlluminanceUnit.Millilux"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Illuminance FromMillilux(double millilux)
+        public static Illuminance FromMillilux(double value)
         {
-            return new Illuminance(millilux, IlluminanceUnit.Millilux);
+            return new Illuminance(value, IlluminanceUnit.Millilux);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs b/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
index 4981926abc..3b0e7de806 100644
--- a/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Impulse.g.cs
@@ -317,117 +317,117 @@ public static string GetAbbreviation(ImpulseUnit unit, IFormatProvider? provider
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.CentinewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromCentinewtonSeconds(double centinewtonseconds)
+        public static Impulse FromCentinewtonSeconds(double value)
         {
-            return new Impulse(centinewtonseconds, ImpulseUnit.CentinewtonSecond);
+            return new Impulse(value, ImpulseUnit.CentinewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.DecanewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromDecanewtonSeconds(double decanewtonseconds)
+        public static Impulse FromDecanewtonSeconds(double value)
         {
-            return new Impulse(decanewtonseconds, ImpulseUnit.DecanewtonSecond);
+            return new Impulse(value, ImpulseUnit.DecanewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.DecinewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromDecinewtonSeconds(double decinewtonseconds)
+        public static Impulse FromDecinewtonSeconds(double value)
         {
-            return new Impulse(decinewtonseconds, ImpulseUnit.DecinewtonSecond);
+            return new Impulse(value, ImpulseUnit.DecinewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.KilogramMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromKilogramMetersPerSecond(double kilogrammeterspersecond)
+        public static Impulse FromKilogramMetersPerSecond(double value)
         {
-            return new Impulse(kilogrammeterspersecond, ImpulseUnit.KilogramMeterPerSecond);
+            return new Impulse(value, ImpulseUnit.KilogramMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.KilonewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromKilonewtonSeconds(double kilonewtonseconds)
+        public static Impulse FromKilonewtonSeconds(double value)
         {
-            return new Impulse(kilonewtonseconds, ImpulseUnit.KilonewtonSecond);
+            return new Impulse(value, ImpulseUnit.KilonewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MeganewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromMeganewtonSeconds(double meganewtonseconds)
+        public static Impulse FromMeganewtonSeconds(double value)
         {
-            return new Impulse(meganewtonseconds, ImpulseUnit.MeganewtonSecond);
+            return new Impulse(value, ImpulseUnit.MeganewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MicronewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromMicronewtonSeconds(double micronewtonseconds)
+        public static Impulse FromMicronewtonSeconds(double value)
         {
-            return new Impulse(micronewtonseconds, ImpulseUnit.MicronewtonSecond);
+            return new Impulse(value, ImpulseUnit.MicronewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.MillinewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromMillinewtonSeconds(double millinewtonseconds)
+        public static Impulse FromMillinewtonSeconds(double value)
         {
-            return new Impulse(millinewtonseconds, ImpulseUnit.MillinewtonSecond);
+            return new Impulse(value, ImpulseUnit.MillinewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.NanonewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromNanonewtonSeconds(double nanonewtonseconds)
+        public static Impulse FromNanonewtonSeconds(double value)
         {
-            return new Impulse(nanonewtonseconds, ImpulseUnit.NanonewtonSecond);
+            return new Impulse(value, ImpulseUnit.NanonewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.NewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromNewtonSeconds(double newtonseconds)
+        public static Impulse FromNewtonSeconds(double value)
         {
-            return new Impulse(newtonseconds, ImpulseUnit.NewtonSecond);
+            return new Impulse(value, ImpulseUnit.NewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.PoundFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromPoundFeetPerSecond(double poundfeetpersecond)
+        public static Impulse FromPoundFeetPerSecond(double value)
         {
-            return new Impulse(poundfeetpersecond, ImpulseUnit.PoundFootPerSecond);
+            return new Impulse(value, ImpulseUnit.PoundFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.PoundForceSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromPoundForceSeconds(double poundforceseconds)
+        public static Impulse FromPoundForceSeconds(double value)
         {
-            return new Impulse(poundforceseconds, ImpulseUnit.PoundForceSecond);
+            return new Impulse(value, ImpulseUnit.PoundForceSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Impulse"/> from <see cref="ImpulseUnit.SlugFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Impulse FromSlugFeetPerSecond(double slugfeetpersecond)
+        public static Impulse FromSlugFeetPerSecond(double value)
         {
-            return new Impulse(slugfeetpersecond, ImpulseUnit.SlugFootPerSecond);
+            return new Impulse(value, ImpulseUnit.SlugFootPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Information.g.cs b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
index 892c978953..cde77174b2 100644
--- a/UnitsNet/GeneratedCode/Quantities/Information.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Information.g.cs
@@ -421,234 +421,234 @@ public static string GetAbbreviation(InformationUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Bit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromBits(double bits)
+        public static Information FromBits(double value)
         {
-            return new Information(bits, InformationUnit.Bit);
+            return new Information(value, InformationUnit.Bit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Byte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromBytes(double bytes)
+        public static Information FromBytes(double value)
         {
-            return new Information(bytes, InformationUnit.Byte);
+            return new Information(value, InformationUnit.Byte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExabits(double exabits)
+        public static Information FromExabits(double value)
         {
-            return new Information(exabits, InformationUnit.Exabit);
+            return new Information(value, InformationUnit.Exabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExabytes(double exabytes)
+        public static Information FromExabytes(double value)
         {
-            return new Information(exabytes, InformationUnit.Exabyte);
+            return new Information(value, InformationUnit.Exabyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExbibits(double exbibits)
+        public static Information FromExbibits(double value)
         {
-            return new Information(exbibits, InformationUnit.Exbibit);
+            return new Information(value, InformationUnit.Exbibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Exbibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromExbibytes(double exbibytes)
+        public static Information FromExbibytes(double value)
         {
-            return new Information(exbibytes, InformationUnit.Exbibyte);
+            return new Information(value, InformationUnit.Exbibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGibibits(double gibibits)
+        public static Information FromGibibits(double value)
         {
-            return new Information(gibibits, InformationUnit.Gibibit);
+            return new Information(value, InformationUnit.Gibibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gibibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGibibytes(double gibibytes)
+        public static Information FromGibibytes(double value)
         {
-            return new Information(gibibytes, InformationUnit.Gibibyte);
+            return new Information(value, InformationUnit.Gibibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGigabits(double gigabits)
+        public static Information FromGigabits(double value)
         {
-            return new Information(gigabits, InformationUnit.Gigabit);
+            return new Information(value, InformationUnit.Gigabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Gigabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromGigabytes(double gigabytes)
+        public static Information FromGigabytes(double value)
         {
-            return new Information(gigabytes, InformationUnit.Gigabyte);
+            return new Information(value, InformationUnit.Gigabyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKibibits(double kibibits)
+        public static Information FromKibibits(double value)
         {
-            return new Information(kibibits, InformationUnit.Kibibit);
+            return new Information(value, InformationUnit.Kibibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kibibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKibibytes(double kibibytes)
+        public static Information FromKibibytes(double value)
         {
-            return new Information(kibibytes, InformationUnit.Kibibyte);
+            return new Information(value, InformationUnit.Kibibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilobit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKilobits(double kilobits)
+        public static Information FromKilobits(double value)
         {
-            return new Information(kilobits, InformationUnit.Kilobit);
+            return new Information(value, InformationUnit.Kilobit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Kilobyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromKilobytes(double kilobytes)
+        public static Information FromKilobytes(double value)
         {
-            return new Information(kilobytes, InformationUnit.Kilobyte);
+            return new Information(value, InformationUnit.Kilobyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMebibits(double mebibits)
+        public static Information FromMebibits(double value)
         {
-            return new Information(mebibits, InformationUnit.Mebibit);
+            return new Information(value, InformationUnit.Mebibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Mebibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMebibytes(double mebibytes)
+        public static Information FromMebibytes(double value)
         {
-            return new Information(mebibytes, InformationUnit.Mebibyte);
+            return new Information(value, InformationUnit.Mebibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMegabits(double megabits)
+        public static Information FromMegabits(double value)
         {
-            return new Information(megabits, InformationUnit.Megabit);
+            return new Information(value, InformationUnit.Megabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Megabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromMegabytes(double megabytes)
+        public static Information FromMegabytes(double value)
         {
-            return new Information(megabytes, InformationUnit.Megabyte);
+            return new Information(value, InformationUnit.Megabyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPebibits(double pebibits)
+        public static Information FromPebibits(double value)
         {
-            return new Information(pebibits, InformationUnit.Pebibit);
+            return new Information(value, InformationUnit.Pebibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Pebibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPebibytes(double pebibytes)
+        public static Information FromPebibytes(double value)
         {
-            return new Information(pebibytes, InformationUnit.Pebibyte);
+            return new Information(value, InformationUnit.Pebibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPetabits(double petabits)
+        public static Information FromPetabits(double value)
         {
-            return new Information(petabits, InformationUnit.Petabit);
+            return new Information(value, InformationUnit.Petabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Petabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromPetabytes(double petabytes)
+        public static Information FromPetabytes(double value)
         {
-            return new Information(petabytes, InformationUnit.Petabyte);
+            return new Information(value, InformationUnit.Petabyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebibit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTebibits(double tebibits)
+        public static Information FromTebibits(double value)
         {
-            return new Information(tebibits, InformationUnit.Tebibit);
+            return new Information(value, InformationUnit.Tebibit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Tebibyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTebibytes(double tebibytes)
+        public static Information FromTebibytes(double value)
         {
-            return new Information(tebibytes, InformationUnit.Tebibyte);
+            return new Information(value, InformationUnit.Tebibyte);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Terabit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTerabits(double terabits)
+        public static Information FromTerabits(double value)
         {
-            return new Information(terabits, InformationUnit.Terabit);
+            return new Information(value, InformationUnit.Terabit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Information"/> from <see cref="InformationUnit.Terabyte"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Information FromTerabytes(double terabytes)
+        public static Information FromTerabytes(double value)
         {
-            return new Information(terabytes, InformationUnit.Terabyte);
+            return new Information(value, InformationUnit.Terabyte);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
index fa1233967f..e2b5a1fac0 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiance.g.cs
@@ -325,126 +325,126 @@ public static string GetAbbreviation(IrradianceUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.KilowattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromKilowattsPerSquareCentimeter(double kilowattspersquarecentimeter)
+        public static Irradiance FromKilowattsPerSquareCentimeter(double value)
         {
-            return new Irradiance(kilowattspersquarecentimeter, IrradianceUnit.KilowattPerSquareCentimeter);
+            return new Irradiance(value, IrradianceUnit.KilowattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.KilowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromKilowattsPerSquareMeter(double kilowattspersquaremeter)
+        public static Irradiance FromKilowattsPerSquareMeter(double value)
         {
-            return new Irradiance(kilowattspersquaremeter, IrradianceUnit.KilowattPerSquareMeter);
+            return new Irradiance(value, IrradianceUnit.KilowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MegawattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMegawattsPerSquareCentimeter(double megawattspersquarecentimeter)
+        public static Irradiance FromMegawattsPerSquareCentimeter(double value)
         {
-            return new Irradiance(megawattspersquarecentimeter, IrradianceUnit.MegawattPerSquareCentimeter);
+            return new Irradiance(value, IrradianceUnit.MegawattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MegawattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMegawattsPerSquareMeter(double megawattspersquaremeter)
+        public static Irradiance FromMegawattsPerSquareMeter(double value)
         {
-            return new Irradiance(megawattspersquaremeter, IrradianceUnit.MegawattPerSquareMeter);
+            return new Irradiance(value, IrradianceUnit.MegawattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MicrowattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMicrowattsPerSquareCentimeter(double microwattspersquarecentimeter)
+        public static Irradiance FromMicrowattsPerSquareCentimeter(double value)
         {
-            return new Irradiance(microwattspersquarecentimeter, IrradianceUnit.MicrowattPerSquareCentimeter);
+            return new Irradiance(value, IrradianceUnit.MicrowattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MicrowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMicrowattsPerSquareMeter(double microwattspersquaremeter)
+        public static Irradiance FromMicrowattsPerSquareMeter(double value)
         {
-            return new Irradiance(microwattspersquaremeter, IrradianceUnit.MicrowattPerSquareMeter);
+            return new Irradiance(value, IrradianceUnit.MicrowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MilliwattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMilliwattsPerSquareCentimeter(double milliwattspersquarecentimeter)
+        public static Irradiance FromMilliwattsPerSquareCentimeter(double value)
         {
-            return new Irradiance(milliwattspersquarecentimeter, IrradianceUnit.MilliwattPerSquareCentimeter);
+            return new Irradiance(value, IrradianceUnit.MilliwattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.MilliwattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromMilliwattsPerSquareMeter(double milliwattspersquaremeter)
+        public static Irradiance FromMilliwattsPerSquareMeter(double value)
         {
-            return new Irradiance(milliwattspersquaremeter, IrradianceUnit.MilliwattPerSquareMeter);
+            return new Irradiance(value, IrradianceUnit.MilliwattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.NanowattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromNanowattsPerSquareCentimeter(double nanowattspersquarecentimeter)
+        public static Irradiance FromNanowattsPerSquareCentimeter(double value)
         {
-            return new Irradiance(nanowattspersquarecentimeter, IrradianceUnit.NanowattPerSquareCentimeter);
+            return new Irradiance(value, IrradianceUnit.NanowattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.NanowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromNanowattsPerSquareMeter(double nanowattspersquaremeter)
+        public static Irradiance FromNanowattsPerSquareMeter(double value)
         {
-            return new Irradiance(nanowattspersquaremeter, IrradianceUnit.NanowattPerSquareMeter);
+            return new Irradiance(value, IrradianceUnit.NanowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.PicowattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromPicowattsPerSquareCentimeter(double picowattspersquarecentimeter)
+        public static Irradiance FromPicowattsPerSquareCentimeter(double value)
         {
-            return new Irradiance(picowattspersquarecentimeter, IrradianceUnit.PicowattPerSquareCentimeter);
+            return new Irradiance(value, IrradianceUnit.PicowattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.PicowattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromPicowattsPerSquareMeter(double picowattspersquaremeter)
+        public static Irradiance FromPicowattsPerSquareMeter(double value)
         {
-            return new Irradiance(picowattspersquaremeter, IrradianceUnit.PicowattPerSquareMeter);
+            return new Irradiance(value, IrradianceUnit.PicowattPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.WattPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromWattsPerSquareCentimeter(double wattspersquarecentimeter)
+        public static Irradiance FromWattsPerSquareCentimeter(double value)
         {
-            return new Irradiance(wattspersquarecentimeter, IrradianceUnit.WattPerSquareCentimeter);
+            return new Irradiance(value, IrradianceUnit.WattPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiance"/> from <see cref="IrradianceUnit.WattPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiance FromWattsPerSquareMeter(double wattspersquaremeter)
+        public static Irradiance FromWattsPerSquareMeter(double value)
         {
-            return new Irradiance(wattspersquaremeter, IrradianceUnit.WattPerSquareMeter);
+            return new Irradiance(value, IrradianceUnit.WattPerSquareMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
index 9d294e4e23..b9aecce6af 100644
--- a/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Irradiation.g.cs
@@ -272,63 +272,63 @@ public static string GetAbbreviation(IrradiationUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareCentimeter(double joulespersquarecentimeter)
+        public static Irradiation FromJoulesPerSquareCentimeter(double value)
         {
-            return new Irradiation(joulespersquarecentimeter, IrradiationUnit.JoulePerSquareCentimeter);
+            return new Irradiation(value, IrradiationUnit.JoulePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareMeter(double joulespersquaremeter)
+        public static Irradiation FromJoulesPerSquareMeter(double value)
         {
-            return new Irradiation(joulespersquaremeter, IrradiationUnit.JoulePerSquareMeter);
+            return new Irradiation(value, IrradiationUnit.JoulePerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.JoulePerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromJoulesPerSquareMillimeter(double joulespersquaremillimeter)
+        public static Irradiation FromJoulesPerSquareMillimeter(double value)
         {
-            return new Irradiation(joulespersquaremillimeter, IrradiationUnit.JoulePerSquareMillimeter);
+            return new Irradiation(value, IrradiationUnit.JoulePerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilojoulePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromKilojoulesPerSquareMeter(double kilojoulespersquaremeter)
+        public static Irradiation FromKilojoulesPerSquareMeter(double value)
         {
-            return new Irradiation(kilojoulespersquaremeter, IrradiationUnit.KilojoulePerSquareMeter);
+            return new Irradiation(value, IrradiationUnit.KilojoulePerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.KilowattHourPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromKilowattHoursPerSquareMeter(double kilowatthourspersquaremeter)
+        public static Irradiation FromKilowattHoursPerSquareMeter(double value)
         {
-            return new Irradiation(kilowatthourspersquaremeter, IrradiationUnit.KilowattHourPerSquareMeter);
+            return new Irradiation(value, IrradiationUnit.KilowattHourPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.MillijoulePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromMillijoulesPerSquareCentimeter(double millijoulespersquarecentimeter)
+        public static Irradiation FromMillijoulesPerSquareCentimeter(double value)
         {
-            return new Irradiation(millijoulespersquarecentimeter, IrradiationUnit.MillijoulePerSquareCentimeter);
+            return new Irradiation(value, IrradiationUnit.MillijoulePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Irradiation"/> from <see cref="IrradiationUnit.WattHourPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Irradiation FromWattHoursPerSquareMeter(double watthourspersquaremeter)
+        public static Irradiation FromWattHoursPerSquareMeter(double value)
         {
-            return new Irradiation(watthourspersquaremeter, IrradiationUnit.WattHourPerSquareMeter);
+            return new Irradiation(value, IrradiationUnit.WattHourPerSquareMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs b/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
index 473fb34652..c52efa5dc8 100644
--- a/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Jerk.g.cs
@@ -301,99 +301,99 @@ public static string GetAbbreviation(JerkUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.CentimeterPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromCentimetersPerSecondCubed(double centimeterspersecondcubed)
+        public static Jerk FromCentimetersPerSecondCubed(double value)
         {
-            return new Jerk(centimeterspersecondcubed, JerkUnit.CentimeterPerSecondCubed);
+            return new Jerk(value, JerkUnit.CentimeterPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.DecimeterPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromDecimetersPerSecondCubed(double decimeterspersecondcubed)
+        public static Jerk FromDecimetersPerSecondCubed(double value)
         {
-            return new Jerk(decimeterspersecondcubed, JerkUnit.DecimeterPerSecondCubed);
+            return new Jerk(value, JerkUnit.DecimeterPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.FootPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromFeetPerSecondCubed(double feetpersecondcubed)
+        public static Jerk FromFeetPerSecondCubed(double value)
         {
-            return new Jerk(feetpersecondcubed, JerkUnit.FootPerSecondCubed);
+            return new Jerk(value, JerkUnit.FootPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.InchPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromInchesPerSecondCubed(double inchespersecondcubed)
+        public static Jerk FromInchesPerSecondCubed(double value)
         {
-            return new Jerk(inchespersecondcubed, JerkUnit.InchPerSecondCubed);
+            return new Jerk(value, JerkUnit.InchPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.KilometerPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromKilometersPerSecondCubed(double kilometerspersecondcubed)
+        public static Jerk FromKilometersPerSecondCubed(double value)
         {
-            return new Jerk(kilometerspersecondcubed, JerkUnit.KilometerPerSecondCubed);
+            return new Jerk(value, JerkUnit.KilometerPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MeterPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromMetersPerSecondCubed(double meterspersecondcubed)
+        public static Jerk FromMetersPerSecondCubed(double value)
         {
-            return new Jerk(meterspersecondcubed, JerkUnit.MeterPerSecondCubed);
+            return new Jerk(value, JerkUnit.MeterPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MicrometerPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromMicrometersPerSecondCubed(double micrometerspersecondcubed)
+        public static Jerk FromMicrometersPerSecondCubed(double value)
         {
-            return new Jerk(micrometerspersecondcubed, JerkUnit.MicrometerPerSecondCubed);
+            return new Jerk(value, JerkUnit.MicrometerPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MillimeterPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromMillimetersPerSecondCubed(double millimeterspersecondcubed)
+        public static Jerk FromMillimetersPerSecondCubed(double value)
         {
-            return new Jerk(millimeterspersecondcubed, JerkUnit.MillimeterPerSecondCubed);
+            return new Jerk(value, JerkUnit.MillimeterPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.MillistandardGravitiesPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromMillistandardGravitiesPerSecond(double millistandardgravitiespersecond)
+        public static Jerk FromMillistandardGravitiesPerSecond(double value)
         {
-            return new Jerk(millistandardgravitiespersecond, JerkUnit.MillistandardGravitiesPerSecond);
+            return new Jerk(value, JerkUnit.MillistandardGravitiesPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.NanometerPerSecondCubed"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromNanometersPerSecondCubed(double nanometerspersecondcubed)
+        public static Jerk FromNanometersPerSecondCubed(double value)
         {
-            return new Jerk(nanometerspersecondcubed, JerkUnit.NanometerPerSecondCubed);
+            return new Jerk(value, JerkUnit.NanometerPerSecondCubed);
         }
 
         /// <summary>
         ///     Creates a <see cref="Jerk"/> from <see cref="JerkUnit.StandardGravitiesPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Jerk FromStandardGravitiesPerSecond(double standardgravitiespersecond)
+        public static Jerk FromStandardGravitiesPerSecond(double value)
         {
-            return new Jerk(standardgravitiespersecond, JerkUnit.StandardGravitiesPerSecond);
+            return new Jerk(value, JerkUnit.StandardGravitiesPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
index 0988035e9f..e668624bac 100644
--- a/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/KinematicViscosity.g.cs
@@ -297,81 +297,81 @@ public static string GetAbbreviation(KinematicViscosityUnit unit, IFormatProvide
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Centistokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromCentistokes(double centistokes)
+        public static KinematicViscosity FromCentistokes(double value)
         {
-            return new KinematicViscosity(centistokes, KinematicViscosityUnit.Centistokes);
+            return new KinematicViscosity(value, KinematicViscosityUnit.Centistokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Decistokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromDecistokes(double decistokes)
+        public static KinematicViscosity FromDecistokes(double value)
         {
-            return new KinematicViscosity(decistokes, KinematicViscosityUnit.Decistokes);
+            return new KinematicViscosity(value, KinematicViscosityUnit.Decistokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Kilostokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromKilostokes(double kilostokes)
+        public static KinematicViscosity FromKilostokes(double value)
         {
-            return new KinematicViscosity(kilostokes, KinematicViscosityUnit.Kilostokes);
+            return new KinematicViscosity(value, KinematicViscosityUnit.Kilostokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Microstokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromMicrostokes(double microstokes)
+        public static KinematicViscosity FromMicrostokes(double value)
         {
-            return new KinematicViscosity(microstokes, KinematicViscosityUnit.Microstokes);
+            return new KinematicViscosity(value, KinematicViscosityUnit.Microstokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Millistokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromMillistokes(double millistokes)
+        public static KinematicViscosity FromMillistokes(double value)
         {
-            return new KinematicViscosity(millistokes, KinematicViscosityUnit.Millistokes);
+            return new KinematicViscosity(value, KinematicViscosityUnit.Millistokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Nanostokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromNanostokes(double nanostokes)
+        public static KinematicViscosity FromNanostokes(double value)
         {
-            return new KinematicViscosity(nanostokes, KinematicViscosityUnit.Nanostokes);
+            return new KinematicViscosity(value, KinematicViscosityUnit.Nanostokes);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.SquareFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromSquareFeetPerSecond(double squarefeetpersecond)
+        public static KinematicViscosity FromSquareFeetPerSecond(double value)
         {
-            return new KinematicViscosity(squarefeetpersecond, KinematicViscosityUnit.SquareFootPerSecond);
+            return new KinematicViscosity(value, KinematicViscosityUnit.SquareFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.SquareMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromSquareMetersPerSecond(double squaremeterspersecond)
+        public static KinematicViscosity FromSquareMetersPerSecond(double value)
         {
-            return new KinematicViscosity(squaremeterspersecond, KinematicViscosityUnit.SquareMeterPerSecond);
+            return new KinematicViscosity(value, KinematicViscosityUnit.SquareMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="KinematicViscosity"/> from <see cref="KinematicViscosityUnit.Stokes"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static KinematicViscosity FromStokes(double stokes)
+        public static KinematicViscosity FromStokes(double value)
         {
-            return new KinematicViscosity(stokes, KinematicViscosityUnit.Stokes);
+            return new KinematicViscosity(value, KinematicViscosityUnit.Stokes);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs b/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
index 0c6ea0fdfe..42c88fbd83 100644
--- a/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LeakRate.g.cs
@@ -240,27 +240,27 @@ public static string GetAbbreviation(LeakRateUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.MillibarLiterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LeakRate FromMillibarLitersPerSecond(double millibarliterspersecond)
+        public static LeakRate FromMillibarLitersPerSecond(double value)
         {
-            return new LeakRate(millibarliterspersecond, LeakRateUnit.MillibarLiterPerSecond);
+            return new LeakRate(value, LeakRateUnit.MillibarLiterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.PascalCubicMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LeakRate FromPascalCubicMetersPerSecond(double pascalcubicmeterspersecond)
+        public static LeakRate FromPascalCubicMetersPerSecond(double value)
         {
-            return new LeakRate(pascalcubicmeterspersecond, LeakRateUnit.PascalCubicMeterPerSecond);
+            return new LeakRate(value, LeakRateUnit.PascalCubicMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="LeakRate"/> from <see cref="LeakRateUnit.TorrLiterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LeakRate FromTorrLitersPerSecond(double torrliterspersecond)
+        public static LeakRate FromTorrLitersPerSecond(double value)
         {
-            return new LeakRate(torrliterspersecond, LeakRateUnit.TorrLiterPerSecond);
+            return new LeakRate(value, LeakRateUnit.TorrLiterPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
index 0a6d1841dd..bd849fd3e5 100644
--- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
@@ -566,378 +566,378 @@ public static string GetAbbreviation(LengthUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Angstrom"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromAngstroms(double angstroms)
+        public static Length FromAngstroms(double value)
         {
-            return new Length(angstroms, LengthUnit.Angstrom);
+            return new Length(value, LengthUnit.Angstrom);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.AstronomicalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromAstronomicalUnits(double astronomicalunits)
+        public static Length FromAstronomicalUnits(double value)
         {
-            return new Length(astronomicalunits, LengthUnit.AstronomicalUnit);
+            return new Length(value, LengthUnit.AstronomicalUnit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Centimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromCentimeters(double centimeters)
+        public static Length FromCentimeters(double value)
         {
-            return new Length(centimeters, LengthUnit.Centimeter);
+            return new Length(value, LengthUnit.Centimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Chain"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromChains(double chains)
+        public static Length FromChains(double value)
         {
-            return new Length(chains, LengthUnit.Chain);
+            return new Length(value, LengthUnit.Chain);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DataMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDataMiles(double datamiles)
+        public static Length FromDataMiles(double value)
         {
-            return new Length(datamiles, LengthUnit.DataMile);
+            return new Length(value, LengthUnit.DataMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Decameter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDecameters(double decameters)
+        public static Length FromDecameters(double value)
         {
-            return new Length(decameters, LengthUnit.Decameter);
+            return new Length(value, LengthUnit.Decameter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Decimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDecimeters(double decimeters)
+        public static Length FromDecimeters(double value)
         {
-            return new Length(decimeters, LengthUnit.Decimeter);
+            return new Length(value, LengthUnit.Decimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DtpPica"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDtpPicas(double dtppicas)
+        public static Length FromDtpPicas(double value)
         {
-            return new Length(dtppicas, LengthUnit.DtpPica);
+            return new Length(value, LengthUnit.DtpPica);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.DtpPoint"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromDtpPoints(double dtppoints)
+        public static Length FromDtpPoints(double value)
         {
-            return new Length(dtppoints, LengthUnit.DtpPoint);
+            return new Length(value, LengthUnit.DtpPoint);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Fathom"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromFathoms(double fathoms)
+        public static Length FromFathoms(double value)
         {
-            return new Length(fathoms, LengthUnit.Fathom);
+            return new Length(value, LengthUnit.Fathom);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Femtometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromFemtometers(double femtometers)
+        public static Length FromFemtometers(double value)
         {
-            return new Length(femtometers, LengthUnit.Femtometer);
+            return new Length(value, LengthUnit.Femtometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Foot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromFeet(double feet)
+        public static Length FromFeet(double value)
         {
-            return new Length(feet, LengthUnit.Foot);
+            return new Length(value, LengthUnit.Foot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Gigameter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromGigameters(double gigameters)
+        public static Length FromGigameters(double value)
         {
-            return new Length(gigameters, LengthUnit.Gigameter);
+            return new Length(value, LengthUnit.Gigameter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Hand"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromHands(double hands)
+        public static Length FromHands(double value)
         {
-            return new Length(hands, LengthUnit.Hand);
+            return new Length(value, LengthUnit.Hand);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Hectometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromHectometers(double hectometers)
+        public static Length FromHectometers(double value)
         {
-            return new Length(hectometers, LengthUnit.Hectometer);
+            return new Length(value, LengthUnit.Hectometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Inch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromInches(double inches)
+        public static Length FromInches(double value)
         {
-            return new Length(inches, LengthUnit.Inch);
+            return new Length(value, LengthUnit.Inch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kilofoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKilofeet(double kilofeet)
+        public static Length FromKilofeet(double value)
         {
-            return new Length(kilofeet, LengthUnit.Kilofoot);
+            return new Length(value, LengthUnit.Kilofoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.KilolightYear"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKilolightYears(double kilolightyears)
+        public static Length FromKilolightYears(double value)
         {
-            return new Length(kilolightyears, LengthUnit.KilolightYear);
+            return new Length(value, LengthUnit.KilolightYear);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKilometers(double kilometers)
+        public static Length FromKilometers(double value)
         {
-            return new Length(kilometers, LengthUnit.Kilometer);
+            return new Length(value, LengthUnit.Kilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kiloparsec"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKiloparsecs(double kiloparsecs)
+        public static Length FromKiloparsecs(double value)
         {
-            return new Length(kiloparsecs, LengthUnit.Kiloparsec);
+            return new Length(value, LengthUnit.Kiloparsec);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Kiloyard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromKiloyards(double kiloyards)
+        public static Length FromKiloyards(double value)
         {
-            return new Length(kiloyards, LengthUnit.Kiloyard);
+            return new Length(value, LengthUnit.Kiloyard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.LightYear"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromLightYears(double lightyears)
+        public static Length FromLightYears(double value)
         {
-            return new Length(lightyears, LengthUnit.LightYear);
+            return new Length(value, LengthUnit.LightYear);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.MegalightYear"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMegalightYears(double megalightyears)
+        public static Length FromMegalightYears(double value)
         {
-            return new Length(megalightyears, LengthUnit.MegalightYear);
+            return new Length(value, LengthUnit.MegalightYear);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Megameter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMegameters(double megameters)
+        public static Length FromMegameters(double value)
         {
-            return new Length(megameters, LengthUnit.Megameter);
+            return new Length(value, LengthUnit.Megameter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Megaparsec"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMegaparsecs(double megaparsecs)
+        public static Length FromMegaparsecs(double value)
         {
-            return new Length(megaparsecs, LengthUnit.Megaparsec);
+            return new Length(value, LengthUnit.Megaparsec);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Meter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMeters(double meters)
+        public static Length FromMeters(double value)
         {
-            return new Length(meters, LengthUnit.Meter);
+            return new Length(value, LengthUnit.Meter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Microinch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMicroinches(double microinches)
+        public static Length FromMicroinches(double value)
         {
-            return new Length(microinches, LengthUnit.Microinch);
+            return new Length(value, LengthUnit.Microinch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Micrometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMicrometers(double micrometers)
+        public static Length FromMicrometers(double value)
         {
-            return new Length(micrometers, LengthUnit.Micrometer);
+            return new Length(value, LengthUnit.Micrometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Mil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMils(double mils)
+        public static Length FromMils(double value)
         {
-            return new Length(mils, LengthUnit.Mil);
+            return new Length(value, LengthUnit.Mil);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Mile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMiles(double miles)
+        public static Length FromMiles(double value)
         {
-            return new Length(miles, LengthUnit.Mile);
+            return new Length(value, LengthUnit.Mile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Millimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromMillimeters(double millimeters)
+        public static Length FromMillimeters(double value)
         {
-            return new Length(millimeters, LengthUnit.Millimeter);
+            return new Length(value, LengthUnit.Millimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Nanometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromNanometers(double nanometers)
+        public static Length FromNanometers(double value)
         {
-            return new Length(nanometers, LengthUnit.Nanometer);
+            return new Length(value, LengthUnit.Nanometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.NauticalMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromNauticalMiles(double nauticalmiles)
+        public static Length FromNauticalMiles(double value)
         {
-            return new Length(nauticalmiles, LengthUnit.NauticalMile);
+            return new Length(value, LengthUnit.NauticalMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Parsec"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromParsecs(double parsecs)
+        public static Length FromParsecs(double value)
         {
-            return new Length(parsecs, LengthUnit.Parsec);
+            return new Length(value, LengthUnit.Parsec);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Picometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromPicometers(double picometers)
+        public static Length FromPicometers(double value)
         {
-            return new Length(picometers, LengthUnit.Picometer);
+            return new Length(value, LengthUnit.Picometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.PrinterPica"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromPrinterPicas(double printerpicas)
+        public static Length FromPrinterPicas(double value)
         {
-            return new Length(printerpicas, LengthUnit.PrinterPica);
+            return new Length(value, LengthUnit.PrinterPica);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.PrinterPoint"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromPrinterPoints(double printerpoints)
+        public static Length FromPrinterPoints(double value)
         {
-            return new Length(printerpoints, LengthUnit.PrinterPoint);
+            return new Length(value, LengthUnit.PrinterPoint);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Shackle"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromShackles(double shackles)
+        public static Length FromShackles(double value)
         {
-            return new Length(shackles, LengthUnit.Shackle);
+            return new Length(value, LengthUnit.Shackle);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.SolarRadius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromSolarRadiuses(double solarradiuses)
+        public static Length FromSolarRadiuses(double value)
         {
-            return new Length(solarradiuses, LengthUnit.SolarRadius);
+            return new Length(value, LengthUnit.SolarRadius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Twip"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromTwips(double twips)
+        public static Length FromTwips(double value)
         {
-            return new Length(twips, LengthUnit.Twip);
+            return new Length(value, LengthUnit.Twip);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.UsSurveyFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromUsSurveyFeet(double ussurveyfeet)
+        public static Length FromUsSurveyFeet(double value)
         {
-            return new Length(ussurveyfeet, LengthUnit.UsSurveyFoot);
+            return new Length(value, LengthUnit.UsSurveyFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Length"/> from <see cref="LengthUnit.Yard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Length FromYards(double yards)
+        public static Length FromYards(double value)
         {
-            return new Length(yards, LengthUnit.Yard);
+            return new Length(value, LengthUnit.Yard);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Level.g.cs b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
index 5343025e4f..3cfbe10c83 100644
--- a/UnitsNet/GeneratedCode/Quantities/Level.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Level.g.cs
@@ -229,18 +229,18 @@ public static string GetAbbreviation(LevelUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Level"/> from <see cref="LevelUnit.Decibel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Level FromDecibels(double decibels)
+        public static Level FromDecibels(double value)
         {
-            return new Level(decibels, LevelUnit.Decibel);
+            return new Level(value, LevelUnit.Decibel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Level"/> from <see cref="LevelUnit.Neper"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Level FromNepers(double nepers)
+        public static Level FromNepers(double value)
         {
-            return new Level(nepers, LevelUnit.Neper);
+            return new Level(value, LevelUnit.Neper);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
index d244dbf6d5..150aad3fda 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
@@ -336,126 +336,126 @@ public static string GetAbbreviation(LinearDensityUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerCentimeter(double gramspercentimeter)
+        public static LinearDensity FromGramsPerCentimeter(double value)
         {
-            return new LinearDensity(gramspercentimeter, LinearDensityUnit.GramPerCentimeter);
+            return new LinearDensity(value, LinearDensityUnit.GramPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerMeter(double gramspermeter)
+        public static LinearDensity FromGramsPerMeter(double value)
         {
-            return new LinearDensity(gramspermeter, LinearDensityUnit.GramPerMeter);
+            return new LinearDensity(value, LinearDensityUnit.GramPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.GramPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromGramsPerMillimeter(double gramspermillimeter)
+        public static LinearDensity FromGramsPerMillimeter(double value)
         {
-            return new LinearDensity(gramspermillimeter, LinearDensityUnit.GramPerMillimeter);
+            return new LinearDensity(value, LinearDensityUnit.GramPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerCentimeter(double kilogramspercentimeter)
+        public static LinearDensity FromKilogramsPerCentimeter(double value)
         {
-            return new LinearDensity(kilogramspercentimeter, LinearDensityUnit.KilogramPerCentimeter);
+            return new LinearDensity(value, LinearDensityUnit.KilogramPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerMeter(double kilogramspermeter)
+        public static LinearDensity FromKilogramsPerMeter(double value)
         {
-            return new LinearDensity(kilogramspermeter, LinearDensityUnit.KilogramPerMeter);
+            return new LinearDensity(value, LinearDensityUnit.KilogramPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.KilogramPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromKilogramsPerMillimeter(double kilogramspermillimeter)
+        public static LinearDensity FromKilogramsPerMillimeter(double value)
         {
-            return new LinearDensity(kilogramspermillimeter, LinearDensityUnit.KilogramPerMillimeter);
+            return new LinearDensity(value, LinearDensityUnit.KilogramPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerCentimeter(double microgramspercentimeter)
+        public static LinearDensity FromMicrogramsPerCentimeter(double value)
         {
-            return new LinearDensity(microgramspercentimeter, LinearDensityUnit.MicrogramPerCentimeter);
+            return new LinearDensity(value, LinearDensityUnit.MicrogramPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerMeter(double microgramspermeter)
+        public static LinearDensity FromMicrogramsPerMeter(double value)
         {
-            return new LinearDensity(microgramspermeter, LinearDensityUnit.MicrogramPerMeter);
+            return new LinearDensity(value, LinearDensityUnit.MicrogramPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MicrogramPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMicrogramsPerMillimeter(double microgramspermillimeter)
+        public static LinearDensity FromMicrogramsPerMillimeter(double value)
         {
-            return new LinearDensity(microgramspermillimeter, LinearDensityUnit.MicrogramPerMillimeter);
+            return new LinearDensity(value, LinearDensityUnit.MicrogramPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerCentimeter(double milligramspercentimeter)
+        public static LinearDensity FromMilligramsPerCentimeter(double value)
         {
-            return new LinearDensity(milligramspercentimeter, LinearDensityUnit.MilligramPerCentimeter);
+            return new LinearDensity(value, LinearDensityUnit.MilligramPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerMeter(double milligramspermeter)
+        public static LinearDensity FromMilligramsPerMeter(double value)
         {
-            return new LinearDensity(milligramspermeter, LinearDensityUnit.MilligramPerMeter);
+            return new LinearDensity(value, LinearDensityUnit.MilligramPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.MilligramPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromMilligramsPerMillimeter(double milligramspermillimeter)
+        public static LinearDensity FromMilligramsPerMillimeter(double value)
         {
-            return new LinearDensity(milligramspermillimeter, LinearDensityUnit.MilligramPerMillimeter);
+            return new LinearDensity(value, LinearDensityUnit.MilligramPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.PoundPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromPoundsPerFoot(double poundsperfoot)
+        public static LinearDensity FromPoundsPerFoot(double value)
         {
-            return new LinearDensity(poundsperfoot, LinearDensityUnit.PoundPerFoot);
+            return new LinearDensity(value, LinearDensityUnit.PoundPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearDensity"/> from <see cref="LinearDensityUnit.PoundPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearDensity FromPoundsPerInch(double poundsperinch)
+        public static LinearDensity FromPoundsPerInch(double value)
         {
-            return new LinearDensity(poundsperinch, LinearDensityUnit.PoundPerInch);
+            return new LinearDensity(value, LinearDensityUnit.PoundPerInch);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
index 900302a53e..c8ecfb66ae 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearPowerDensity.g.cs
@@ -416,225 +416,225 @@ public static string GetAbbreviation(LinearPowerDensityUnit unit, IFormatProvide
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerCentimeter(double gigawattspercentimeter)
+        public static LinearPowerDensity FromGigawattsPerCentimeter(double value)
         {
-            return new LinearPowerDensity(gigawattspercentimeter, LinearPowerDensityUnit.GigawattPerCentimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerFoot(double gigawattsperfoot)
+        public static LinearPowerDensity FromGigawattsPerFoot(double value)
         {
-            return new LinearPowerDensity(gigawattsperfoot, LinearPowerDensityUnit.GigawattPerFoot);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerInch(double gigawattsperinch)
+        public static LinearPowerDensity FromGigawattsPerInch(double value)
         {
-            return new LinearPowerDensity(gigawattsperinch, LinearPowerDensityUnit.GigawattPerInch);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerMeter(double gigawattspermeter)
+        public static LinearPowerDensity FromGigawattsPerMeter(double value)
         {
-            return new LinearPowerDensity(gigawattspermeter, LinearPowerDensityUnit.GigawattPerMeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.GigawattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromGigawattsPerMillimeter(double gigawattspermillimeter)
+        public static LinearPowerDensity FromGigawattsPerMillimeter(double value)
         {
-            return new LinearPowerDensity(gigawattspermillimeter, LinearPowerDensityUnit.GigawattPerMillimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.GigawattPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerCentimeter(double kilowattspercentimeter)
+        public static LinearPowerDensity FromKilowattsPerCentimeter(double value)
         {
-            return new LinearPowerDensity(kilowattspercentimeter, LinearPowerDensityUnit.KilowattPerCentimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerFoot(double kilowattsperfoot)
+        public static LinearPowerDensity FromKilowattsPerFoot(double value)
         {
-            return new LinearPowerDensity(kilowattsperfoot, LinearPowerDensityUnit.KilowattPerFoot);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerInch(double kilowattsperinch)
+        public static LinearPowerDensity FromKilowattsPerInch(double value)
         {
-            return new LinearPowerDensity(kilowattsperinch, LinearPowerDensityUnit.KilowattPerInch);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerMeter(double kilowattspermeter)
+        public static LinearPowerDensity FromKilowattsPerMeter(double value)
         {
-            return new LinearPowerDensity(kilowattspermeter, LinearPowerDensityUnit.KilowattPerMeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.KilowattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromKilowattsPerMillimeter(double kilowattspermillimeter)
+        public static LinearPowerDensity FromKilowattsPerMillimeter(double value)
         {
-            return new LinearPowerDensity(kilowattspermillimeter, LinearPowerDensityUnit.KilowattPerMillimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.KilowattPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerCentimeter(double megawattspercentimeter)
+        public static LinearPowerDensity FromMegawattsPerCentimeter(double value)
         {
-            return new LinearPowerDensity(megawattspercentimeter, LinearPowerDensityUnit.MegawattPerCentimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerFoot(double megawattsperfoot)
+        public static LinearPowerDensity FromMegawattsPerFoot(double value)
         {
-            return new LinearPowerDensity(megawattsperfoot, LinearPowerDensityUnit.MegawattPerFoot);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerInch(double megawattsperinch)
+        public static LinearPowerDensity FromMegawattsPerInch(double value)
         {
-            return new LinearPowerDensity(megawattsperinch, LinearPowerDensityUnit.MegawattPerInch);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerMeter(double megawattspermeter)
+        public static LinearPowerDensity FromMegawattsPerMeter(double value)
         {
-            return new LinearPowerDensity(megawattspermeter, LinearPowerDensityUnit.MegawattPerMeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MegawattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMegawattsPerMillimeter(double megawattspermillimeter)
+        public static LinearPowerDensity FromMegawattsPerMillimeter(double value)
         {
-            return new LinearPowerDensity(megawattspermillimeter, LinearPowerDensityUnit.MegawattPerMillimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MegawattPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerCentimeter(double milliwattspercentimeter)
+        public static LinearPowerDensity FromMilliwattsPerCentimeter(double value)
         {
-            return new LinearPowerDensity(milliwattspercentimeter, LinearPowerDensityUnit.MilliwattPerCentimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerFoot(double milliwattsperfoot)
+        public static LinearPowerDensity FromMilliwattsPerFoot(double value)
         {
-            return new LinearPowerDensity(milliwattsperfoot, LinearPowerDensityUnit.MilliwattPerFoot);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerInch(double milliwattsperinch)
+        public static LinearPowerDensity FromMilliwattsPerInch(double value)
         {
-            return new LinearPowerDensity(milliwattsperinch, LinearPowerDensityUnit.MilliwattPerInch);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerMeter(double milliwattspermeter)
+        public static LinearPowerDensity FromMilliwattsPerMeter(double value)
         {
-            return new LinearPowerDensity(milliwattspermeter, LinearPowerDensityUnit.MilliwattPerMeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.MilliwattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromMilliwattsPerMillimeter(double milliwattspermillimeter)
+        public static LinearPowerDensity FromMilliwattsPerMillimeter(double value)
         {
-            return new LinearPowerDensity(milliwattspermillimeter, LinearPowerDensityUnit.MilliwattPerMillimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.MilliwattPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerCentimeter(double wattspercentimeter)
+        public static LinearPowerDensity FromWattsPerCentimeter(double value)
         {
-            return new LinearPowerDensity(wattspercentimeter, LinearPowerDensityUnit.WattPerCentimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerFoot(double wattsperfoot)
+        public static LinearPowerDensity FromWattsPerFoot(double value)
         {
-            return new LinearPowerDensity(wattsperfoot, LinearPowerDensityUnit.WattPerFoot);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerInch(double wattsperinch)
+        public static LinearPowerDensity FromWattsPerInch(double value)
         {
-            return new LinearPowerDensity(wattsperinch, LinearPowerDensityUnit.WattPerInch);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerMeter(double wattspermeter)
+        public static LinearPowerDensity FromWattsPerMeter(double value)
         {
-            return new LinearPowerDensity(wattspermeter, LinearPowerDensityUnit.WattPerMeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="LinearPowerDensity"/> from <see cref="LinearPowerDensityUnit.WattPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LinearPowerDensity FromWattsPerMillimeter(double wattspermillimeter)
+        public static LinearPowerDensity FromWattsPerMillimeter(double value)
         {
-            return new LinearPowerDensity(wattspermillimeter, LinearPowerDensityUnit.WattPerMillimeter);
+            return new LinearPowerDensity(value, LinearPowerDensityUnit.WattPerMillimeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
index c7f77fe15a..7aeb3c7428 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminance.g.cs
@@ -302,90 +302,90 @@ public static string GetAbbreviation(LuminanceUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromCandelasPerSquareFoot(double candelaspersquarefoot)
+        public static Luminance FromCandelasPerSquareFoot(double value)
         {
-            return new Luminance(candelaspersquarefoot, LuminanceUnit.CandelaPerSquareFoot);
+            return new Luminance(value, LuminanceUnit.CandelaPerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromCandelasPerSquareInch(double candelaspersquareinch)
+        public static Luminance FromCandelasPerSquareInch(double value)
         {
-            return new Luminance(candelaspersquareinch, LuminanceUnit.CandelaPerSquareInch);
+            return new Luminance(value, LuminanceUnit.CandelaPerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromCandelasPerSquareMeter(double candelaspersquaremeter)
+        public static Luminance FromCandelasPerSquareMeter(double value)
         {
-            return new Luminance(candelaspersquaremeter, LuminanceUnit.CandelaPerSquareMeter);
+            return new Luminance(value, LuminanceUnit.CandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.CenticandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromCenticandelasPerSquareMeter(double centicandelaspersquaremeter)
+        public static Luminance FromCenticandelasPerSquareMeter(double value)
         {
-            return new Luminance(centicandelaspersquaremeter, LuminanceUnit.CenticandelaPerSquareMeter);
+            return new Luminance(value, LuminanceUnit.CenticandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.DecicandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromDecicandelasPerSquareMeter(double decicandelaspersquaremeter)
+        public static Luminance FromDecicandelasPerSquareMeter(double value)
         {
-            return new Luminance(decicandelaspersquaremeter, LuminanceUnit.DecicandelaPerSquareMeter);
+            return new Luminance(value, LuminanceUnit.DecicandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.KilocandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromKilocandelasPerSquareMeter(double kilocandelaspersquaremeter)
+        public static Luminance FromKilocandelasPerSquareMeter(double value)
         {
-            return new Luminance(kilocandelaspersquaremeter, LuminanceUnit.KilocandelaPerSquareMeter);
+            return new Luminance(value, LuminanceUnit.KilocandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.MicrocandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromMicrocandelasPerSquareMeter(double microcandelaspersquaremeter)
+        public static Luminance FromMicrocandelasPerSquareMeter(double value)
         {
-            return new Luminance(microcandelaspersquaremeter, LuminanceUnit.MicrocandelaPerSquareMeter);
+            return new Luminance(value, LuminanceUnit.MicrocandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.MillicandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromMillicandelasPerSquareMeter(double millicandelaspersquaremeter)
+        public static Luminance FromMillicandelasPerSquareMeter(double value)
         {
-            return new Luminance(millicandelaspersquaremeter, LuminanceUnit.MillicandelaPerSquareMeter);
+            return new Luminance(value, LuminanceUnit.MillicandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.NanocandelaPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromNanocandelasPerSquareMeter(double nanocandelaspersquaremeter)
+        public static Luminance FromNanocandelasPerSquareMeter(double value)
         {
-            return new Luminance(nanocandelaspersquaremeter, LuminanceUnit.NanocandelaPerSquareMeter);
+            return new Luminance(value, LuminanceUnit.NanocandelaPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminance"/> from <see cref="LuminanceUnit.Nit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminance FromNits(double nits)
+        public static Luminance FromNits(double value)
         {
-            return new Luminance(nits, LuminanceUnit.Nit);
+            return new Luminance(value, LuminanceUnit.Nit);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
index 0df8fb7e24..00dec263fa 100644
--- a/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Luminosity.g.cs
@@ -328,126 +328,126 @@ public static string GetAbbreviation(LuminosityUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Decawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromDecawatts(double decawatts)
+        public static Luminosity FromDecawatts(double value)
         {
-            return new Luminosity(decawatts, LuminosityUnit.Decawatt);
+            return new Luminosity(value, LuminosityUnit.Decawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Deciwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromDeciwatts(double deciwatts)
+        public static Luminosity FromDeciwatts(double value)
         {
-            return new Luminosity(deciwatts, LuminosityUnit.Deciwatt);
+            return new Luminosity(value, LuminosityUnit.Deciwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Femtowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromFemtowatts(double femtowatts)
+        public static Luminosity FromFemtowatts(double value)
         {
-            return new Luminosity(femtowatts, LuminosityUnit.Femtowatt);
+            return new Luminosity(value, LuminosityUnit.Femtowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Gigawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromGigawatts(double gigawatts)
+        public static Luminosity FromGigawatts(double value)
         {
-            return new Luminosity(gigawatts, LuminosityUnit.Gigawatt);
+            return new Luminosity(value, LuminosityUnit.Gigawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Kilowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromKilowatts(double kilowatts)
+        public static Luminosity FromKilowatts(double value)
         {
-            return new Luminosity(kilowatts, LuminosityUnit.Kilowatt);
+            return new Luminosity(value, LuminosityUnit.Kilowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Megawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMegawatts(double megawatts)
+        public static Luminosity FromMegawatts(double value)
         {
-            return new Luminosity(megawatts, LuminosityUnit.Megawatt);
+            return new Luminosity(value, LuminosityUnit.Megawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Microwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMicrowatts(double microwatts)
+        public static Luminosity FromMicrowatts(double value)
         {
-            return new Luminosity(microwatts, LuminosityUnit.Microwatt);
+            return new Luminosity(value, LuminosityUnit.Microwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Milliwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromMilliwatts(double milliwatts)
+        public static Luminosity FromMilliwatts(double value)
         {
-            return new Luminosity(milliwatts, LuminosityUnit.Milliwatt);
+            return new Luminosity(value, LuminosityUnit.Milliwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Nanowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromNanowatts(double nanowatts)
+        public static Luminosity FromNanowatts(double value)
         {
-            return new Luminosity(nanowatts, LuminosityUnit.Nanowatt);
+            return new Luminosity(value, LuminosityUnit.Nanowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Petawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromPetawatts(double petawatts)
+        public static Luminosity FromPetawatts(double value)
         {
-            return new Luminosity(petawatts, LuminosityUnit.Petawatt);
+            return new Luminosity(value, LuminosityUnit.Petawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Picowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromPicowatts(double picowatts)
+        public static Luminosity FromPicowatts(double value)
         {
-            return new Luminosity(picowatts, LuminosityUnit.Picowatt);
+            return new Luminosity(value, LuminosityUnit.Picowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.SolarLuminosity"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromSolarLuminosities(double solarluminosities)
+        public static Luminosity FromSolarLuminosities(double value)
         {
-            return new Luminosity(solarluminosities, LuminosityUnit.SolarLuminosity);
+            return new Luminosity(value, LuminosityUnit.SolarLuminosity);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Terawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromTerawatts(double terawatts)
+        public static Luminosity FromTerawatts(double value)
         {
-            return new Luminosity(terawatts, LuminosityUnit.Terawatt);
+            return new Luminosity(value, LuminosityUnit.Terawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Luminosity"/> from <see cref="LuminosityUnit.Watt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Luminosity FromWatts(double watts)
+        public static Luminosity FromWatts(double value)
         {
-            return new Luminosity(watts, LuminosityUnit.Watt);
+            return new Luminosity(value, LuminosityUnit.Watt);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
index 785e2c1a02..9ab25d187b 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousFlux.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(LuminousFluxUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="LuminousFlux"/> from <see cref="LuminousFluxUnit.Lumen"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LuminousFlux FromLumens(double lumens)
+        public static LuminousFlux FromLumens(double value)
         {
-            return new LuminousFlux(lumens, LuminousFluxUnit.Lumen);
+            return new LuminousFlux(value, LuminousFluxUnit.Lumen);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
index 43d4a65664..a82a6831b8 100644
--- a/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LuminousIntensity.g.cs
@@ -231,9 +231,9 @@ public static string GetAbbreviation(LuminousIntensityUnit unit, IFormatProvider
         ///     Creates a <see cref="LuminousIntensity"/> from <see cref="LuminousIntensityUnit.Candela"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static LuminousIntensity FromCandela(double candela)
+        public static LuminousIntensity FromCandela(double value)
         {
-            return new LuminousIntensity(candela, LuminousIntensityUnit.Candela);
+            return new LuminousIntensity(value, LuminousIntensityUnit.Candela);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
index 583f0dcbd5..1b161d5d12 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticField.g.cs
@@ -264,54 +264,54 @@ public static string GetAbbreviation(MagneticFieldUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Gauss"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromGausses(double gausses)
+        public static MagneticField FromGausses(double value)
         {
-            return new MagneticField(gausses, MagneticFieldUnit.Gauss);
+            return new MagneticField(value, MagneticFieldUnit.Gauss);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Microtesla"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromMicroteslas(double microteslas)
+        public static MagneticField FromMicroteslas(double value)
         {
-            return new MagneticField(microteslas, MagneticFieldUnit.Microtesla);
+            return new MagneticField(value, MagneticFieldUnit.Microtesla);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Milligauss"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromMilligausses(double milligausses)
+        public static MagneticField FromMilligausses(double value)
         {
-            return new MagneticField(milligausses, MagneticFieldUnit.Milligauss);
+            return new MagneticField(value, MagneticFieldUnit.Milligauss);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Millitesla"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromMilliteslas(double milliteslas)
+        public static MagneticField FromMilliteslas(double value)
         {
-            return new MagneticField(milliteslas, MagneticFieldUnit.Millitesla);
+            return new MagneticField(value, MagneticFieldUnit.Millitesla);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Nanotesla"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromNanoteslas(double nanoteslas)
+        public static MagneticField FromNanoteslas(double value)
         {
-            return new MagneticField(nanoteslas, MagneticFieldUnit.Nanotesla);
+            return new MagneticField(value, MagneticFieldUnit.Nanotesla);
         }
 
         /// <summary>
         ///     Creates a <see cref="MagneticField"/> from <see cref="MagneticFieldUnit.Tesla"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticField FromTeslas(double teslas)
+        public static MagneticField FromTeslas(double value)
         {
-            return new MagneticField(teslas, MagneticFieldUnit.Tesla);
+            return new MagneticField(value, MagneticFieldUnit.Tesla);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
index 15465cb859..80e3a9b0fc 100644
--- a/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MagneticFlux.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(MagneticFluxUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="MagneticFlux"/> from <see cref="MagneticFluxUnit.Weber"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MagneticFlux FromWebers(double webers)
+        public static MagneticFlux FromWebers(double value)
         {
-            return new MagneticFlux(webers, MagneticFluxUnit.Weber);
+            return new MagneticFlux(value, MagneticFluxUnit.Weber);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
index df422b1ca0..2d589711e7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Magnetization.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(MagnetizationUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="Magnetization"/> from <see cref="MagnetizationUnit.AmperePerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Magnetization FromAmperesPerMeter(double amperespermeter)
+        public static Magnetization FromAmperesPerMeter(double value)
         {
-            return new Magnetization(amperespermeter, MagnetizationUnit.AmperePerMeter);
+            return new Magnetization(value, MagnetizationUnit.AmperePerMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
index 1d5da4b22d..d9e495fee2 100644
--- a/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Mass.g.cs
@@ -449,243 +449,243 @@ public static string GetAbbreviation(MassUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Centigram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromCentigrams(double centigrams)
+        public static Mass FromCentigrams(double value)
         {
-            return new Mass(centigrams, MassUnit.Centigram);
+            return new Mass(value, MassUnit.Centigram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Decagram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromDecagrams(double decagrams)
+        public static Mass FromDecagrams(double value)
         {
-            return new Mass(decagrams, MassUnit.Decagram);
+            return new Mass(value, MassUnit.Decagram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Decigram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromDecigrams(double decigrams)
+        public static Mass FromDecigrams(double value)
         {
-            return new Mass(decigrams, MassUnit.Decigram);
+            return new Mass(value, MassUnit.Decigram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.EarthMass"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromEarthMasses(double earthmasses)
+        public static Mass FromEarthMasses(double value)
         {
-            return new Mass(earthmasses, MassUnit.EarthMass);
+            return new Mass(value, MassUnit.EarthMass);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Femtogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromFemtograms(double femtograms)
+        public static Mass FromFemtograms(double value)
         {
-            return new Mass(femtograms, MassUnit.Femtogram);
+            return new Mass(value, MassUnit.Femtogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Grain"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromGrains(double grains)
+        public static Mass FromGrains(double value)
         {
-            return new Mass(grains, MassUnit.Grain);
+            return new Mass(value, MassUnit.Grain);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Gram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromGrams(double grams)
+        public static Mass FromGrams(double value)
         {
-            return new Mass(grams, MassUnit.Gram);
+            return new Mass(value, MassUnit.Gram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Hectogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromHectograms(double hectograms)
+        public static Mass FromHectograms(double value)
         {
-            return new Mass(hectograms, MassUnit.Hectogram);
+            return new Mass(value, MassUnit.Hectogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilograms(double kilograms)
+        public static Mass FromKilograms(double value)
         {
-            return new Mass(kilograms, MassUnit.Kilogram);
+            return new Mass(value, MassUnit.Kilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilopound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilopounds(double kilopounds)
+        public static Mass FromKilopounds(double value)
         {
-            return new Mass(kilopounds, MassUnit.Kilopound);
+            return new Mass(value, MassUnit.Kilopound);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Kilotonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromKilotonnes(double kilotonnes)
+        public static Mass FromKilotonnes(double value)
         {
-            return new Mass(kilotonnes, MassUnit.Kilotonne);
+            return new Mass(value, MassUnit.Kilotonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.LongHundredweight"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromLongHundredweight(double longhundredweight)
+        public static Mass FromLongHundredweight(double value)
         {
-            return new Mass(longhundredweight, MassUnit.LongHundredweight);
+            return new Mass(value, MassUnit.LongHundredweight);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.LongTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromLongTons(double longtons)
+        public static Mass FromLongTons(double value)
         {
-            return new Mass(longtons, MassUnit.LongTon);
+            return new Mass(value, MassUnit.LongTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megapound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMegapounds(double megapounds)
+        public static Mass FromMegapounds(double value)
         {
-            return new Mass(megapounds, MassUnit.Megapound);
+            return new Mass(value, MassUnit.Megapound);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Megatonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMegatonnes(double megatonnes)
+        public static Mass FromMegatonnes(double value)
         {
-            return new Mass(megatonnes, MassUnit.Megatonne);
+            return new Mass(value, MassUnit.Megatonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Microgram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMicrograms(double micrograms)
+        public static Mass FromMicrograms(double value)
         {
-            return new Mass(micrograms, MassUnit.Microgram);
+            return new Mass(value, MassUnit.Microgram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Milligram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromMilligrams(double milligrams)
+        public static Mass FromMilligrams(double value)
         {
-            return new Mass(milligrams, MassUnit.Milligram);
+            return new Mass(value, MassUnit.Milligram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Nanogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromNanograms(double nanograms)
+        public static Mass FromNanograms(double value)
         {
-            return new Mass(nanograms, MassUnit.Nanogram);
+            return new Mass(value, MassUnit.Nanogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Ounce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromOunces(double ounces)
+        public static Mass FromOunces(double value)
         {
-            return new Mass(ounces, MassUnit.Ounce);
+            return new Mass(value, MassUnit.Ounce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Picogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromPicograms(double picograms)
+        public static Mass FromPicograms(double value)
         {
-            return new Mass(picograms, MassUnit.Picogram);
+            return new Mass(value, MassUnit.Picogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Pound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromPounds(double pounds)
+        public static Mass FromPounds(double value)
         {
-            return new Mass(pounds, MassUnit.Pound);
+            return new Mass(value, MassUnit.Pound);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.ShortHundredweight"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromShortHundredweight(double shorthundredweight)
+        public static Mass FromShortHundredweight(double value)
         {
-            return new Mass(shorthundredweight, MassUnit.ShortHundredweight);
+            return new Mass(value, MassUnit.ShortHundredweight);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.ShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromShortTons(double shorttons)
+        public static Mass FromShortTons(double value)
         {
-            return new Mass(shorttons, MassUnit.ShortTon);
+            return new Mass(value, MassUnit.ShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Slug"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromSlugs(double slugs)
+        public static Mass FromSlugs(double value)
         {
-            return new Mass(slugs, MassUnit.Slug);
+            return new Mass(value, MassUnit.Slug);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.SolarMass"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromSolarMasses(double solarmasses)
+        public static Mass FromSolarMasses(double value)
         {
-            return new Mass(solarmasses, MassUnit.SolarMass);
+            return new Mass(value, MassUnit.SolarMass);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Stone"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromStone(double stone)
+        public static Mass FromStone(double value)
         {
-            return new Mass(stone, MassUnit.Stone);
+            return new Mass(value, MassUnit.Stone);
         }
 
         /// <summary>
         ///     Creates a <see cref="Mass"/> from <see cref="MassUnit.Tonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Mass FromTonnes(double tonnes)
+        public static Mass FromTonnes(double value)
         {
-            return new Mass(tonnes, MassUnit.Tonne);
+            return new Mass(value, MassUnit.Tonne);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
index 5c3625f8f9..bd7feec1d8 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -616,441 +616,441 @@ public static string GetAbbreviation(MassConcentrationUnit unit, IFormatProvider
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerDeciliter(double centigramsperdeciliter)
+        public static MassConcentration FromCentigramsPerDeciliter(double value)
         {
-            return new MassConcentration(centigramsperdeciliter, MassConcentrationUnit.CentigramPerDeciliter);
+            return new MassConcentration(value, MassConcentrationUnit.CentigramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerLiter(double centigramsperliter)
+        public static MassConcentration FromCentigramsPerLiter(double value)
         {
-            return new MassConcentration(centigramsperliter, MassConcentrationUnit.CentigramPerLiter);
+            return new MassConcentration(value, MassConcentrationUnit.CentigramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerMicroliter(double centigramspermicroliter)
+        public static MassConcentration FromCentigramsPerMicroliter(double value)
         {
-            return new MassConcentration(centigramspermicroliter, MassConcentrationUnit.CentigramPerMicroliter);
+            return new MassConcentration(value, MassConcentrationUnit.CentigramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.CentigramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromCentigramsPerMilliliter(double centigramspermilliliter)
+        public static MassConcentration FromCentigramsPerMilliliter(double value)
         {
-            return new MassConcentration(centigramspermilliliter, MassConcentrationUnit.CentigramPerMilliliter);
+            return new MassConcentration(value, MassConcentrationUnit.CentigramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerDeciliter(double decigramsperdeciliter)
+        public static MassConcentration FromDecigramsPerDeciliter(double value)
         {
-            return new MassConcentration(decigramsperdeciliter, MassConcentrationUnit.DecigramPerDeciliter);
+            return new MassConcentration(value, MassConcentrationUnit.DecigramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerLiter(double decigramsperliter)
+        public static MassConcentration FromDecigramsPerLiter(double value)
         {
-            return new MassConcentration(decigramsperliter, MassConcentrationUnit.DecigramPerLiter);
+            return new MassConcentration(value, MassConcentrationUnit.DecigramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerMicroliter(double decigramspermicroliter)
+        public static MassConcentration FromDecigramsPerMicroliter(double value)
         {
-            return new MassConcentration(decigramspermicroliter, MassConcentrationUnit.DecigramPerMicroliter);
+            return new MassConcentration(value, MassConcentrationUnit.DecigramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.DecigramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromDecigramsPerMilliliter(double decigramspermilliliter)
+        public static MassConcentration FromDecigramsPerMilliliter(double value)
         {
-            return new MassConcentration(decigramspermilliliter, MassConcentrationUnit.DecigramPerMilliliter);
+            return new MassConcentration(value, MassConcentrationUnit.DecigramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicCentimeter(double gramspercubiccentimeter)
+        public static MassConcentration FromGramsPerCubicCentimeter(double value)
         {
-            return new MassConcentration(gramspercubiccentimeter, MassConcentrationUnit.GramPerCubicCentimeter);
+            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicMeter(double gramspercubicmeter)
+        public static MassConcentration FromGramsPerCubicMeter(double value)
         {
-            return new MassConcentration(gramspercubicmeter, MassConcentrationUnit.GramPerCubicMeter);
+            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerCubicMillimeter(double gramspercubicmillimeter)
+        public static MassConcentration FromGramsPerCubicMillimeter(double value)
         {
-            return new MassConcentration(gramspercubicmillimeter, MassConcentrationUnit.GramPerCubicMillimeter);
+            return new MassConcentration(value, MassConcentrationUnit.GramPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerDeciliter(double gramsperdeciliter)
+        public static MassConcentration FromGramsPerDeciliter(double value)
         {
-            return new MassConcentration(gramsperdeciliter, MassConcentrationUnit.GramPerDeciliter);
+            return new MassConcentration(value, MassConcentrationUnit.GramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerLiter(double gramsperliter)
+        public static MassConcentration FromGramsPerLiter(double value)
         {
-            return new MassConcentration(gramsperliter, MassConcentrationUnit.GramPerLiter);
+            return new MassConcentration(value, MassConcentrationUnit.GramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerMicroliter(double gramspermicroliter)
+        public static MassConcentration FromGramsPerMicroliter(double value)
         {
-            return new MassConcentration(gramspermicroliter, MassConcentrationUnit.GramPerMicroliter);
+            return new MassConcentration(value, MassConcentrationUnit.GramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.GramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromGramsPerMilliliter(double gramspermilliliter)
+        public static MassConcentration FromGramsPerMilliliter(double value)
         {
-            return new MassConcentration(gramspermilliliter, MassConcentrationUnit.GramPerMilliliter);
+            return new MassConcentration(value, MassConcentrationUnit.GramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicCentimeter(double kilogramspercubiccentimeter)
+        public static MassConcentration FromKilogramsPerCubicCentimeter(double value)
         {
-            return new MassConcentration(kilogramspercubiccentimeter, MassConcentrationUnit.KilogramPerCubicCentimeter);
+            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicMeter(double kilogramspercubicmeter)
+        public static MassConcentration FromKilogramsPerCubicMeter(double value)
         {
-            return new MassConcentration(kilogramspercubicmeter, MassConcentrationUnit.KilogramPerCubicMeter);
+            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerCubicMillimeter(double kilogramspercubicmillimeter)
+        public static MassConcentration FromKilogramsPerCubicMillimeter(double value)
         {
-            return new MassConcentration(kilogramspercubicmillimeter, MassConcentrationUnit.KilogramPerCubicMillimeter);
+            return new MassConcentration(value, MassConcentrationUnit.KilogramPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilogramsPerLiter(double kilogramsperliter)
+        public static MassConcentration FromKilogramsPerLiter(double value)
         {
-            return new MassConcentration(kilogramsperliter, MassConcentrationUnit.KilogramPerLiter);
+            return new MassConcentration(value, MassConcentrationUnit.KilogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilopoundPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilopoundsPerCubicFoot(double kilopoundspercubicfoot)
+        public static MassConcentration FromKilopoundsPerCubicFoot(double value)
         {
-            return new MassConcentration(kilopoundspercubicfoot, MassConcentrationUnit.KilopoundPerCubicFoot);
+            return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.KilopoundPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromKilopoundsPerCubicInch(double kilopoundspercubicinch)
+        public static MassConcentration FromKilopoundsPerCubicInch(double value)
         {
-            return new MassConcentration(kilopoundspercubicinch, MassConcentrationUnit.KilopoundPerCubicInch);
+            return new MassConcentration(value, MassConcentrationUnit.KilopoundPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerCubicMeter(double microgramspercubicmeter)
+        public static MassConcentration FromMicrogramsPerCubicMeter(double value)
         {
-            return new MassConcentration(microgramspercubicmeter, MassConcentrationUnit.MicrogramPerCubicMeter);
+            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerDeciliter(double microgramsperdeciliter)
+        public static MassConcentration FromMicrogramsPerDeciliter(double value)
         {
-            return new MassConcentration(microgramsperdeciliter, MassConcentrationUnit.MicrogramPerDeciliter);
+            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerLiter(double microgramsperliter)
+        public static MassConcentration FromMicrogramsPerLiter(double value)
         {
-            return new MassConcentration(microgramsperliter, MassConcentrationUnit.MicrogramPerLiter);
+            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerMicroliter(double microgramspermicroliter)
+        public static MassConcentration FromMicrogramsPerMicroliter(double value)
         {
-            return new MassConcentration(microgramspermicroliter, MassConcentrationUnit.MicrogramPerMicroliter);
+            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MicrogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMicrogramsPerMilliliter(double microgramspermilliliter)
+        public static MassConcentration FromMicrogramsPerMilliliter(double value)
         {
-            return new MassConcentration(microgramspermilliliter, MassConcentrationUnit.MicrogramPerMilliliter);
+            return new MassConcentration(value, MassConcentrationUnit.MicrogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerCubicMeter(double milligramspercubicmeter)
+        public static MassConcentration FromMilligramsPerCubicMeter(double value)
         {
-            return new MassConcentration(milligramspercubicmeter, MassConcentrationUnit.MilligramPerCubicMeter);
+            return new MassConcentration(value, MassConcentrationUnit.MilligramPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerDeciliter(double milligramsperdeciliter)
+        public static MassConcentration FromMilligramsPerDeciliter(double value)
         {
-            return new MassConcentration(milligramsperdeciliter, MassConcentrationUnit.MilligramPerDeciliter);
+            return new MassConcentration(value, MassConcentrationUnit.MilligramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerLiter(double milligramsperliter)
+        public static MassConcentration FromMilligramsPerLiter(double value)
         {
-            return new MassConcentration(milligramsperliter, MassConcentrationUnit.MilligramPerLiter);
+            return new MassConcentration(value, MassConcentrationUnit.MilligramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerMicroliter(double milligramspermicroliter)
+        public static MassConcentration FromMilligramsPerMicroliter(double value)
         {
-            return new MassConcentration(milligramspermicroliter, MassConcentrationUnit.MilligramPerMicroliter);
+            return new MassConcentration(value, MassConcentrationUnit.MilligramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.MilligramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromMilligramsPerMilliliter(double milligramspermilliliter)
+        public static MassConcentration FromMilligramsPerMilliliter(double value)
         {
-            return new MassConcentration(milligramspermilliliter, MassConcentrationUnit.MilligramPerMilliliter);
+            return new MassConcentration(value, MassConcentrationUnit.MilligramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerDeciliter(double nanogramsperdeciliter)
+        public static MassConcentration FromNanogramsPerDeciliter(double value)
         {
-            return new MassConcentration(nanogramsperdeciliter, MassConcentrationUnit.NanogramPerDeciliter);
+            return new MassConcentration(value, MassConcentrationUnit.NanogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerLiter(double nanogramsperliter)
+        public static MassConcentration FromNanogramsPerLiter(double value)
         {
-            return new MassConcentration(nanogramsperliter, MassConcentrationUnit.NanogramPerLiter);
+            return new MassConcentration(value, MassConcentrationUnit.NanogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerMicroliter(double nanogramspermicroliter)
+        public static MassConcentration FromNanogramsPerMicroliter(double value)
         {
-            return new MassConcentration(nanogramspermicroliter, MassConcentrationUnit.NanogramPerMicroliter);
+            return new MassConcentration(value, MassConcentrationUnit.NanogramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.NanogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromNanogramsPerMilliliter(double nanogramspermilliliter)
+        public static MassConcentration FromNanogramsPerMilliliter(double value)
         {
-            return new MassConcentration(nanogramspermilliliter, MassConcentrationUnit.NanogramPerMilliliter);
+            return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.OuncePerImperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromOuncesPerImperialGallon(double ouncesperimperialgallon)
+        public static MassConcentration FromOuncesPerImperialGallon(double value)
         {
-            return new MassConcentration(ouncesperimperialgallon, MassConcentrationUnit.OuncePerImperialGallon);
+            return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.OuncePerUSGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromOuncesPerUSGallon(double ouncesperusgallon)
+        public static MassConcentration FromOuncesPerUSGallon(double value)
         {
-            return new MassConcentration(ouncesperusgallon, MassConcentrationUnit.OuncePerUSGallon);
+            return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerDeciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerDeciliter(double picogramsperdeciliter)
+        public static MassConcentration FromPicogramsPerDeciliter(double value)
         {
-            return new MassConcentration(picogramsperdeciliter, MassConcentrationUnit.PicogramPerDeciliter);
+            return new MassConcentration(value, MassConcentrationUnit.PicogramPerDeciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerLiter(double picogramsperliter)
+        public static MassConcentration FromPicogramsPerLiter(double value)
         {
-            return new MassConcentration(picogramsperliter, MassConcentrationUnit.PicogramPerLiter);
+            return new MassConcentration(value, MassConcentrationUnit.PicogramPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerMicroliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerMicroliter(double picogramspermicroliter)
+        public static MassConcentration FromPicogramsPerMicroliter(double value)
         {
-            return new MassConcentration(picogramspermicroliter, MassConcentrationUnit.PicogramPerMicroliter);
+            return new MassConcentration(value, MassConcentrationUnit.PicogramPerMicroliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PicogramPerMilliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPicogramsPerMilliliter(double picogramspermilliliter)
+        public static MassConcentration FromPicogramsPerMilliliter(double value)
         {
-            return new MassConcentration(picogramspermilliliter, MassConcentrationUnit.PicogramPerMilliliter);
+            return new MassConcentration(value, MassConcentrationUnit.PicogramPerMilliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerCubicFoot(double poundspercubicfoot)
+        public static MassConcentration FromPoundsPerCubicFoot(double value)
         {
-            return new MassConcentration(poundspercubicfoot, MassConcentrationUnit.PoundPerCubicFoot);
+            return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerCubicInch(double poundspercubicinch)
+        public static MassConcentration FromPoundsPerCubicInch(double value)
         {
-            return new MassConcentration(poundspercubicinch, MassConcentrationUnit.PoundPerCubicInch);
+            return new MassConcentration(value, MassConcentrationUnit.PoundPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerImperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerImperialGallon(double poundsperimperialgallon)
+        public static MassConcentration FromPoundsPerImperialGallon(double value)
         {
-            return new MassConcentration(poundsperimperialgallon, MassConcentrationUnit.PoundPerImperialGallon);
+            return new MassConcentration(value, MassConcentrationUnit.PoundPerImperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.PoundPerUSGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromPoundsPerUSGallon(double poundsperusgallon)
+        public static MassConcentration FromPoundsPerUSGallon(double value)
         {
-            return new MassConcentration(poundsperusgallon, MassConcentrationUnit.PoundPerUSGallon);
+            return new MassConcentration(value, MassConcentrationUnit.PoundPerUSGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.SlugPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromSlugsPerCubicFoot(double slugspercubicfoot)
+        public static MassConcentration FromSlugsPerCubicFoot(double value)
         {
-            return new MassConcentration(slugspercubicfoot, MassConcentrationUnit.SlugPerCubicFoot);
+            return new MassConcentration(value, MassConcentrationUnit.SlugPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicCentimeter(double tonnespercubiccentimeter)
+        public static MassConcentration FromTonnesPerCubicCentimeter(double value)
         {
-            return new MassConcentration(tonnespercubiccentimeter, MassConcentrationUnit.TonnePerCubicCentimeter);
+            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicMeter(double tonnespercubicmeter)
+        public static MassConcentration FromTonnesPerCubicMeter(double value)
         {
-            return new MassConcentration(tonnespercubicmeter, MassConcentrationUnit.TonnePerCubicMeter);
+            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassConcentration"/> from <see cref="MassConcentrationUnit.TonnePerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassConcentration FromTonnesPerCubicMillimeter(double tonnespercubicmillimeter)
+        public static MassConcentration FromTonnesPerCubicMillimeter(double value)
         {
-            return new MassConcentration(tonnespercubicmillimeter, MassConcentrationUnit.TonnePerCubicMillimeter);
+            return new MassConcentration(value, MassConcentrationUnit.TonnePerCubicMillimeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
index 07ecac8e86..22b9d72ef2 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlow.g.cs
@@ -491,297 +491,297 @@ public static string GetAbbreviation(MassFlowUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.CentigramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromCentigramsPerDay(double centigramsperday)
+        public static MassFlow FromCentigramsPerDay(double value)
         {
-            return new MassFlow(centigramsperday, MassFlowUnit.CentigramPerDay);
+            return new MassFlow(value, MassFlowUnit.CentigramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.CentigramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromCentigramsPerSecond(double centigramspersecond)
+        public static MassFlow FromCentigramsPerSecond(double value)
         {
-            return new MassFlow(centigramspersecond, MassFlowUnit.CentigramPerSecond);
+            return new MassFlow(value, MassFlowUnit.CentigramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecagramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecagramsPerDay(double decagramsperday)
+        public static MassFlow FromDecagramsPerDay(double value)
         {
-            return new MassFlow(decagramsperday, MassFlowUnit.DecagramPerDay);
+            return new MassFlow(value, MassFlowUnit.DecagramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecagramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecagramsPerSecond(double decagramspersecond)
+        public static MassFlow FromDecagramsPerSecond(double value)
         {
-            return new MassFlow(decagramspersecond, MassFlowUnit.DecagramPerSecond);
+            return new MassFlow(value, MassFlowUnit.DecagramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecigramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecigramsPerDay(double decigramsperday)
+        public static MassFlow FromDecigramsPerDay(double value)
         {
-            return new MassFlow(decigramsperday, MassFlowUnit.DecigramPerDay);
+            return new MassFlow(value, MassFlowUnit.DecigramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.DecigramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromDecigramsPerSecond(double decigramspersecond)
+        public static MassFlow FromDecigramsPerSecond(double value)
         {
-            return new MassFlow(decigramspersecond, MassFlowUnit.DecigramPerSecond);
+            return new MassFlow(value, MassFlowUnit.DecigramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerDay(double gramsperday)
+        public static MassFlow FromGramsPerDay(double value)
         {
-            return new MassFlow(gramsperday, MassFlowUnit.GramPerDay);
+            return new MassFlow(value, MassFlowUnit.GramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerHour(double gramsperhour)
+        public static MassFlow FromGramsPerHour(double value)
         {
-            return new MassFlow(gramsperhour, MassFlowUnit.GramPerHour);
+            return new MassFlow(value, MassFlowUnit.GramPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.GramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromGramsPerSecond(double gramspersecond)
+        public static MassFlow FromGramsPerSecond(double value)
         {
-            return new MassFlow(gramspersecond, MassFlowUnit.GramPerSecond);
+            return new MassFlow(value, MassFlowUnit.GramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.HectogramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromHectogramsPerDay(double hectogramsperday)
+        public static MassFlow FromHectogramsPerDay(double value)
         {
-            return new MassFlow(hectogramsperday, MassFlowUnit.HectogramPerDay);
+            return new MassFlow(value, MassFlowUnit.HectogramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.HectogramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromHectogramsPerSecond(double hectogramspersecond)
+        public static MassFlow FromHectogramsPerSecond(double value)
         {
-            return new MassFlow(hectogramspersecond, MassFlowUnit.HectogramPerSecond);
+            return new MassFlow(value, MassFlowUnit.HectogramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerDay(double kilogramsperday)
+        public static MassFlow FromKilogramsPerDay(double value)
         {
-            return new MassFlow(kilogramsperday, MassFlowUnit.KilogramPerDay);
+            return new MassFlow(value, MassFlowUnit.KilogramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerHour(double kilogramsperhour)
+        public static MassFlow FromKilogramsPerHour(double value)
         {
-            return new MassFlow(kilogramsperhour, MassFlowUnit.KilogramPerHour);
+            return new MassFlow(value, MassFlowUnit.KilogramPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerMinute(double kilogramsperminute)
+        public static MassFlow FromKilogramsPerMinute(double value)
         {
-            return new MassFlow(kilogramsperminute, MassFlowUnit.KilogramPerMinute);
+            return new MassFlow(value, MassFlowUnit.KilogramPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.KilogramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromKilogramsPerSecond(double kilogramspersecond)
+        public static MassFlow FromKilogramsPerSecond(double value)
         {
-            return new MassFlow(kilogramspersecond, MassFlowUnit.KilogramPerSecond);
+            return new MassFlow(value, MassFlowUnit.KilogramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegagramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegagramsPerDay(double megagramsperday)
+        public static MassFlow FromMegagramsPerDay(double value)
         {
-            return new MassFlow(megagramsperday, MassFlowUnit.MegagramPerDay);
+            return new MassFlow(value, MassFlowUnit.MegagramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerDay(double megapoundsperday)
+        public static MassFlow FromMegapoundsPerDay(double value)
         {
-            return new MassFlow(megapoundsperday, MassFlowUnit.MegapoundPerDay);
+            return new MassFlow(value, MassFlowUnit.MegapoundPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerHour(double megapoundsperhour)
+        public static MassFlow FromMegapoundsPerHour(double value)
         {
-            return new MassFlow(megapoundsperhour, MassFlowUnit.MegapoundPerHour);
+            return new MassFlow(value, MassFlowUnit.MegapoundPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerMinute(double megapoundsperminute)
+        public static MassFlow FromMegapoundsPerMinute(double value)
         {
-            return new MassFlow(megapoundsperminute, MassFlowUnit.MegapoundPerMinute);
+            return new MassFlow(value, MassFlowUnit.MegapoundPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MegapoundPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMegapoundsPerSecond(double megapoundspersecond)
+        public static MassFlow FromMegapoundsPerSecond(double value)
         {
-            return new MassFlow(megapoundspersecond, MassFlowUnit.MegapoundPerSecond);
+            return new MassFlow(value, MassFlowUnit.MegapoundPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MicrogramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMicrogramsPerDay(double microgramsperday)
+        public static MassFlow FromMicrogramsPerDay(double value)
         {
-            return new MassFlow(microgramsperday, MassFlowUnit.MicrogramPerDay);
+            return new MassFlow(value, MassFlowUnit.MicrogramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MicrogramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMicrogramsPerSecond(double microgramspersecond)
+        public static MassFlow FromMicrogramsPerSecond(double value)
         {
-            return new MassFlow(microgramspersecond, MassFlowUnit.MicrogramPerSecond);
+            return new MassFlow(value, MassFlowUnit.MicrogramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MilligramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMilligramsPerDay(double milligramsperday)
+        public static MassFlow FromMilligramsPerDay(double value)
         {
-            return new MassFlow(milligramsperday, MassFlowUnit.MilligramPerDay);
+            return new MassFlow(value, MassFlowUnit.MilligramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.MilligramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromMilligramsPerSecond(double milligramspersecond)
+        public static MassFlow FromMilligramsPerSecond(double value)
         {
-            return new MassFlow(milligramspersecond, MassFlowUnit.MilligramPerSecond);
+            return new MassFlow(value, MassFlowUnit.MilligramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.NanogramPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromNanogramsPerDay(double nanogramsperday)
+        public static MassFlow FromNanogramsPerDay(double value)
         {
-            return new MassFlow(nanogramsperday, MassFlowUnit.NanogramPerDay);
+            return new MassFlow(value, MassFlowUnit.NanogramPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.NanogramPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromNanogramsPerSecond(double nanogramspersecond)
+        public static MassFlow FromNanogramsPerSecond(double value)
         {
-            return new MassFlow(nanogramspersecond, MassFlowUnit.NanogramPerSecond);
+            return new MassFlow(value, MassFlowUnit.NanogramPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerDay(double poundsperday)
+        public static MassFlow FromPoundsPerDay(double value)
         {
-            return new MassFlow(poundsperday, MassFlowUnit.PoundPerDay);
+            return new MassFlow(value, MassFlowUnit.PoundPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerHour(double poundsperhour)
+        public static MassFlow FromPoundsPerHour(double value)
         {
-            return new MassFlow(poundsperhour, MassFlowUnit.PoundPerHour);
+            return new MassFlow(value, MassFlowUnit.PoundPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerMinute(double poundsperminute)
+        public static MassFlow FromPoundsPerMinute(double value)
         {
-            return new MassFlow(poundsperminute, MassFlowUnit.PoundPerMinute);
+            return new MassFlow(value, MassFlowUnit.PoundPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.PoundPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromPoundsPerSecond(double poundspersecond)
+        public static MassFlow FromPoundsPerSecond(double value)
         {
-            return new MassFlow(poundspersecond, MassFlowUnit.PoundPerSecond);
+            return new MassFlow(value, MassFlowUnit.PoundPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.ShortTonPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromShortTonsPerHour(double shorttonsperhour)
+        public static MassFlow FromShortTonsPerHour(double value)
         {
-            return new MassFlow(shorttonsperhour, MassFlowUnit.ShortTonPerHour);
+            return new MassFlow(value, MassFlowUnit.ShortTonPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.TonnePerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromTonnesPerDay(double tonnesperday)
+        public static MassFlow FromTonnesPerDay(double value)
         {
-            return new MassFlow(tonnesperday, MassFlowUnit.TonnePerDay);
+            return new MassFlow(value, MassFlowUnit.TonnePerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlow"/> from <see cref="MassFlowUnit.TonnePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlow FromTonnesPerHour(double tonnesperhour)
+        public static MassFlow FromTonnesPerHour(double value)
         {
-            return new MassFlow(tonnesperhour, MassFlowUnit.TonnePerHour);
+            return new MassFlow(value, MassFlowUnit.TonnePerHour);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
index 5e65d320c1..77e91ab108 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFlux.g.cs
@@ -317,108 +317,108 @@ public static string GetAbbreviation(MassFluxUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareCentimeter(double gramsperhourpersquarecentimeter)
+        public static MassFlux FromGramsPerHourPerSquareCentimeter(double value)
         {
-            return new MassFlux(gramsperhourpersquarecentimeter, MassFluxUnit.GramPerHourPerSquareCentimeter);
+            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareMeter(double gramsperhourpersquaremeter)
+        public static MassFlux FromGramsPerHourPerSquareMeter(double value)
         {
-            return new MassFlux(gramsperhourpersquaremeter, MassFluxUnit.GramPerHourPerSquareMeter);
+            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerHourPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerHourPerSquareMillimeter(double gramsperhourpersquaremillimeter)
+        public static MassFlux FromGramsPerHourPerSquareMillimeter(double value)
         {
-            return new MassFlux(gramsperhourpersquaremillimeter, MassFluxUnit.GramPerHourPerSquareMillimeter);
+            return new MassFlux(value, MassFluxUnit.GramPerHourPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareCentimeter(double gramspersecondpersquarecentimeter)
+        public static MassFlux FromGramsPerSecondPerSquareCentimeter(double value)
         {
-            return new MassFlux(gramspersecondpersquarecentimeter, MassFluxUnit.GramPerSecondPerSquareCentimeter);
+            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareMeter(double gramspersecondpersquaremeter)
+        public static MassFlux FromGramsPerSecondPerSquareMeter(double value)
         {
-            return new MassFlux(gramspersecondpersquaremeter, MassFluxUnit.GramPerSecondPerSquareMeter);
+            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.GramPerSecondPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromGramsPerSecondPerSquareMillimeter(double gramspersecondpersquaremillimeter)
+        public static MassFlux FromGramsPerSecondPerSquareMillimeter(double value)
         {
-            return new MassFlux(gramspersecondpersquaremillimeter, MassFluxUnit.GramPerSecondPerSquareMillimeter);
+            return new MassFlux(value, MassFluxUnit.GramPerSecondPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareCentimeter(double kilogramsperhourpersquarecentimeter)
+        public static MassFlux FromKilogramsPerHourPerSquareCentimeter(double value)
         {
-            return new MassFlux(kilogramsperhourpersquarecentimeter, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
+            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareMeter(double kilogramsperhourpersquaremeter)
+        public static MassFlux FromKilogramsPerHourPerSquareMeter(double value)
         {
-            return new MassFlux(kilogramsperhourpersquaremeter, MassFluxUnit.KilogramPerHourPerSquareMeter);
+            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerHourPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerHourPerSquareMillimeter(double kilogramsperhourpersquaremillimeter)
+        public static MassFlux FromKilogramsPerHourPerSquareMillimeter(double value)
         {
-            return new MassFlux(kilogramsperhourpersquaremillimeter, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
+            return new MassFlux(value, MassFluxUnit.KilogramPerHourPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(double kilogramspersecondpersquarecentimeter)
+        public static MassFlux FromKilogramsPerSecondPerSquareCentimeter(double value)
         {
-            return new MassFlux(kilogramspersecondpersquarecentimeter, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
+            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareMeter(double kilogramspersecondpersquaremeter)
+        public static MassFlux FromKilogramsPerSecondPerSquareMeter(double value)
         {
-            return new MassFlux(kilogramspersecondpersquaremeter, MassFluxUnit.KilogramPerSecondPerSquareMeter);
+            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFlux"/> from <see cref="MassFluxUnit.KilogramPerSecondPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(double kilogramspersecondpersquaremillimeter)
+        public static MassFlux FromKilogramsPerSecondPerSquareMillimeter(double value)
         {
-            return new MassFlux(kilogramspersecondpersquaremillimeter, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
+            return new MassFlux(value, MassFluxUnit.KilogramPerSecondPerSquareMillimeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
index 391b74441d..0ade3af47b 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassFraction.g.cs
@@ -414,216 +414,216 @@ public static string GetAbbreviation(MassFractionUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.CentigramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromCentigramsPerGram(double centigramspergram)
+        public static MassFraction FromCentigramsPerGram(double value)
         {
-            return new MassFraction(centigramspergram, MassFractionUnit.CentigramPerGram);
+            return new MassFraction(value, MassFractionUnit.CentigramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.CentigramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromCentigramsPerKilogram(double centigramsperkilogram)
+        public static MassFraction FromCentigramsPerKilogram(double value)
         {
-            return new MassFraction(centigramsperkilogram, MassFractionUnit.CentigramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.CentigramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecagramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecagramsPerGram(double decagramspergram)
+        public static MassFraction FromDecagramsPerGram(double value)
         {
-            return new MassFraction(decagramspergram, MassFractionUnit.DecagramPerGram);
+            return new MassFraction(value, MassFractionUnit.DecagramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecagramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecagramsPerKilogram(double decagramsperkilogram)
+        public static MassFraction FromDecagramsPerKilogram(double value)
         {
-            return new MassFraction(decagramsperkilogram, MassFractionUnit.DecagramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.DecagramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecigramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecigramsPerGram(double decigramspergram)
+        public static MassFraction FromDecigramsPerGram(double value)
         {
-            return new MassFraction(decigramspergram, MassFractionUnit.DecigramPerGram);
+            return new MassFraction(value, MassFractionUnit.DecigramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecigramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecigramsPerKilogram(double decigramsperkilogram)
+        public static MassFraction FromDecigramsPerKilogram(double value)
         {
-            return new MassFraction(decigramsperkilogram, MassFractionUnit.DecigramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.DecigramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.DecimalFraction"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromDecimalFractions(double decimalfractions)
+        public static MassFraction FromDecimalFractions(double value)
         {
-            return new MassFraction(decimalfractions, MassFractionUnit.DecimalFraction);
+            return new MassFraction(value, MassFractionUnit.DecimalFraction);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.GramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromGramsPerGram(double gramspergram)
+        public static MassFraction FromGramsPerGram(double value)
         {
-            return new MassFraction(gramspergram, MassFractionUnit.GramPerGram);
+            return new MassFraction(value, MassFractionUnit.GramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.GramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromGramsPerKilogram(double gramsperkilogram)
+        public static MassFraction FromGramsPerKilogram(double value)
         {
-            return new MassFraction(gramsperkilogram, MassFractionUnit.GramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.GramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.HectogramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromHectogramsPerGram(double hectogramspergram)
+        public static MassFraction FromHectogramsPerGram(double value)
         {
-            return new MassFraction(hectogramspergram, MassFractionUnit.HectogramPerGram);
+            return new MassFraction(value, MassFractionUnit.HectogramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.HectogramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromHectogramsPerKilogram(double hectogramsperkilogram)
+        public static MassFraction FromHectogramsPerKilogram(double value)
         {
-            return new MassFraction(hectogramsperkilogram, MassFractionUnit.HectogramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.HectogramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.KilogramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromKilogramsPerGram(double kilogramspergram)
+        public static MassFraction FromKilogramsPerGram(double value)
         {
-            return new MassFraction(kilogramspergram, MassFractionUnit.KilogramPerGram);
+            return new MassFraction(value, MassFractionUnit.KilogramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.KilogramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromKilogramsPerKilogram(double kilogramsperkilogram)
+        public static MassFraction FromKilogramsPerKilogram(double value)
         {
-            return new MassFraction(kilogramsperkilogram, MassFractionUnit.KilogramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.KilogramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MicrogramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMicrogramsPerGram(double microgramspergram)
+        public static MassFraction FromMicrogramsPerGram(double value)
         {
-            return new MassFraction(microgramspergram, MassFractionUnit.MicrogramPerGram);
+            return new MassFraction(value, MassFractionUnit.MicrogramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MicrogramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMicrogramsPerKilogram(double microgramsperkilogram)
+        public static MassFraction FromMicrogramsPerKilogram(double value)
         {
-            return new MassFraction(microgramsperkilogram, MassFractionUnit.MicrogramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.MicrogramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MilligramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMilligramsPerGram(double milligramspergram)
+        public static MassFraction FromMilligramsPerGram(double value)
         {
-            return new MassFraction(milligramspergram, MassFractionUnit.MilligramPerGram);
+            return new MassFraction(value, MassFractionUnit.MilligramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.MilligramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromMilligramsPerKilogram(double milligramsperkilogram)
+        public static MassFraction FromMilligramsPerKilogram(double value)
         {
-            return new MassFraction(milligramsperkilogram, MassFractionUnit.MilligramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.MilligramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.NanogramPerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromNanogramsPerGram(double nanogramspergram)
+        public static MassFraction FromNanogramsPerGram(double value)
         {
-            return new MassFraction(nanogramspergram, MassFractionUnit.NanogramPerGram);
+            return new MassFraction(value, MassFractionUnit.NanogramPerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.NanogramPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromNanogramsPerKilogram(double nanogramsperkilogram)
+        public static MassFraction FromNanogramsPerKilogram(double value)
         {
-            return new MassFraction(nanogramsperkilogram, MassFractionUnit.NanogramPerKilogram);
+            return new MassFraction(value, MassFractionUnit.NanogramPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerBillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerBillion(double partsperbillion)
+        public static MassFraction FromPartsPerBillion(double value)
         {
-            return new MassFraction(partsperbillion, MassFractionUnit.PartPerBillion);
+            return new MassFraction(value, MassFractionUnit.PartPerBillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerMillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerMillion(double partspermillion)
+        public static MassFraction FromPartsPerMillion(double value)
         {
-            return new MassFraction(partspermillion, MassFractionUnit.PartPerMillion);
+            return new MassFraction(value, MassFractionUnit.PartPerMillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerThousand"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerThousand(double partsperthousand)
+        public static MassFraction FromPartsPerThousand(double value)
         {
-            return new MassFraction(partsperthousand, MassFractionUnit.PartPerThousand);
+            return new MassFraction(value, MassFractionUnit.PartPerThousand);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.PartPerTrillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPartsPerTrillion(double partspertrillion)
+        public static MassFraction FromPartsPerTrillion(double value)
         {
-            return new MassFraction(partspertrillion, MassFractionUnit.PartPerTrillion);
+            return new MassFraction(value, MassFractionUnit.PartPerTrillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassFraction"/> from <see cref="MassFractionUnit.Percent"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassFraction FromPercent(double percent)
+        public static MassFraction FromPercent(double value)
         {
-            return new MassFraction(percent, MassFractionUnit.Percent);
+            return new MassFraction(value, MassFractionUnit.Percent);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
index 1c0c81e360..ac7c6a34a8 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassMomentOfInertia.g.cs
@@ -437,252 +437,252 @@ public static string GetAbbreviation(MassMomentOfInertiaUnit unit, IFormatProvid
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareCentimeters(double gramsquarecentimeters)
+        public static MassMomentOfInertia FromGramSquareCentimeters(double value)
         {
-            return new MassMomentOfInertia(gramsquarecentimeters, MassMomentOfInertiaUnit.GramSquareCentimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareDecimeters(double gramsquaredecimeters)
+        public static MassMomentOfInertia FromGramSquareDecimeters(double value)
         {
-            return new MassMomentOfInertia(gramsquaredecimeters, MassMomentOfInertiaUnit.GramSquareDecimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareMeters(double gramsquaremeters)
+        public static MassMomentOfInertia FromGramSquareMeters(double value)
         {
-            return new MassMomentOfInertia(gramsquaremeters, MassMomentOfInertiaUnit.GramSquareMeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.GramSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromGramSquareMillimeters(double gramsquaremillimeters)
+        public static MassMomentOfInertia FromGramSquareMillimeters(double value)
         {
-            return new MassMomentOfInertia(gramsquaremillimeters, MassMomentOfInertiaUnit.GramSquareMillimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.GramSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareCentimeters(double kilogramsquarecentimeters)
+        public static MassMomentOfInertia FromKilogramSquareCentimeters(double value)
         {
-            return new MassMomentOfInertia(kilogramsquarecentimeters, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareDecimeters(double kilogramsquaredecimeters)
+        public static MassMomentOfInertia FromKilogramSquareDecimeters(double value)
         {
-            return new MassMomentOfInertia(kilogramsquaredecimeters, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareMeters(double kilogramsquaremeters)
+        public static MassMomentOfInertia FromKilogramSquareMeters(double value)
         {
-            return new MassMomentOfInertia(kilogramsquaremeters, MassMomentOfInertiaUnit.KilogramSquareMeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilogramSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilogramSquareMillimeters(double kilogramsquaremillimeters)
+        public static MassMomentOfInertia FromKilogramSquareMillimeters(double value)
         {
-            return new MassMomentOfInertia(kilogramsquaremillimeters, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilogramSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareCentimeters(double kilotonnesquarecentimeters)
+        public static MassMomentOfInertia FromKilotonneSquareCentimeters(double value)
         {
-            return new MassMomentOfInertia(kilotonnesquarecentimeters, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareDecimeters(double kilotonnesquaredecimeters)
+        public static MassMomentOfInertia FromKilotonneSquareDecimeters(double value)
         {
-            return new MassMomentOfInertia(kilotonnesquaredecimeters, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareMeters(double kilotonnesquaremeters)
+        public static MassMomentOfInertia FromKilotonneSquareMeters(double value)
         {
-            return new MassMomentOfInertia(kilotonnesquaremeters, MassMomentOfInertiaUnit.KilotonneSquareMeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.KilotonneSquareMilimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromKilotonneSquareMilimeters(double kilotonnesquaremilimeters)
+        public static MassMomentOfInertia FromKilotonneSquareMilimeters(double value)
         {
-            return new MassMomentOfInertia(kilotonnesquaremilimeters, MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.KilotonneSquareMilimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareCentimeters(double megatonnesquarecentimeters)
+        public static MassMomentOfInertia FromMegatonneSquareCentimeters(double value)
         {
-            return new MassMomentOfInertia(megatonnesquarecentimeters, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareDecimeters(double megatonnesquaredecimeters)
+        public static MassMomentOfInertia FromMegatonneSquareDecimeters(double value)
         {
-            return new MassMomentOfInertia(megatonnesquaredecimeters, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareMeters(double megatonnesquaremeters)
+        public static MassMomentOfInertia FromMegatonneSquareMeters(double value)
         {
-            return new MassMomentOfInertia(megatonnesquaremeters, MassMomentOfInertiaUnit.MegatonneSquareMeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MegatonneSquareMilimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMegatonneSquareMilimeters(double megatonnesquaremilimeters)
+        public static MassMomentOfInertia FromMegatonneSquareMilimeters(double value)
         {
-            return new MassMomentOfInertia(megatonnesquaremilimeters, MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MegatonneSquareMilimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareCentimeters(double milligramsquarecentimeters)
+        public static MassMomentOfInertia FromMilligramSquareCentimeters(double value)
         {
-            return new MassMomentOfInertia(milligramsquarecentimeters, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareDecimeters(double milligramsquaredecimeters)
+        public static MassMomentOfInertia FromMilligramSquareDecimeters(double value)
         {
-            return new MassMomentOfInertia(milligramsquaredecimeters, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareMeters(double milligramsquaremeters)
+        public static MassMomentOfInertia FromMilligramSquareMeters(double value)
         {
-            return new MassMomentOfInertia(milligramsquaremeters, MassMomentOfInertiaUnit.MilligramSquareMeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.MilligramSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromMilligramSquareMillimeters(double milligramsquaremillimeters)
+        public static MassMomentOfInertia FromMilligramSquareMillimeters(double value)
         {
-            return new MassMomentOfInertia(milligramsquaremillimeters, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.MilligramSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.PoundSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromPoundSquareFeet(double poundsquarefeet)
+        public static MassMomentOfInertia FromPoundSquareFeet(double value)
         {
-            return new MassMomentOfInertia(poundsquarefeet, MassMomentOfInertiaUnit.PoundSquareFoot);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.PoundSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromPoundSquareInches(double poundsquareinches)
+        public static MassMomentOfInertia FromPoundSquareInches(double value)
         {
-            return new MassMomentOfInertia(poundsquareinches, MassMomentOfInertiaUnit.PoundSquareInch);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.PoundSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.SlugSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromSlugSquareFeet(double slugsquarefeet)
+        public static MassMomentOfInertia FromSlugSquareFeet(double value)
         {
-            return new MassMomentOfInertia(slugsquarefeet, MassMomentOfInertiaUnit.SlugSquareFoot);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.SlugSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromSlugSquareInches(double slugsquareinches)
+        public static MassMomentOfInertia FromSlugSquareInches(double value)
         {
-            return new MassMomentOfInertia(slugsquareinches, MassMomentOfInertiaUnit.SlugSquareInch);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.SlugSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareCentimeters(double tonnesquarecentimeters)
+        public static MassMomentOfInertia FromTonneSquareCentimeters(double value)
         {
-            return new MassMomentOfInertia(tonnesquarecentimeters, MassMomentOfInertiaUnit.TonneSquareCentimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareDecimeters(double tonnesquaredecimeters)
+        public static MassMomentOfInertia FromTonneSquareDecimeters(double value)
         {
-            return new MassMomentOfInertia(tonnesquaredecimeters, MassMomentOfInertiaUnit.TonneSquareDecimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareMeters(double tonnesquaremeters)
+        public static MassMomentOfInertia FromTonneSquareMeters(double value)
         {
-            return new MassMomentOfInertia(tonnesquaremeters, MassMomentOfInertiaUnit.TonneSquareMeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="MassMomentOfInertia"/> from <see cref="MassMomentOfInertiaUnit.TonneSquareMilimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MassMomentOfInertia FromTonneSquareMilimeters(double tonnesquaremilimeters)
+        public static MassMomentOfInertia FromTonneSquareMilimeters(double value)
         {
-            return new MassMomentOfInertia(tonnesquaremilimeters, MassMomentOfInertiaUnit.TonneSquareMilimeter);
+            return new MassMomentOfInertia(value, MassMomentOfInertiaUnit.TonneSquareMilimeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Molality.g.cs b/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
index da1b9a2d1b..017d459c53 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molality.g.cs
@@ -232,18 +232,18 @@ public static string GetAbbreviation(MolalityUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MolePerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molality FromMolesPerGram(double molespergram)
+        public static Molality FromMolesPerGram(double value)
         {
-            return new Molality(molespergram, MolalityUnit.MolePerGram);
+            return new Molality(value, MolalityUnit.MolePerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molality"/> from <see cref="MolalityUnit.MolePerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molality FromMolesPerKilogram(double molesperkilogram)
+        public static Molality FromMolesPerKilogram(double value)
         {
-            return new Molality(molesperkilogram, MolalityUnit.MolePerKilogram);
+            return new Molality(value, MolalityUnit.MolePerKilogram);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
index bfba26db00..f30bdc6f7f 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEnergy.g.cs
@@ -237,27 +237,27 @@ public static string GetAbbreviation(MolarEnergyUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.JoulePerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromJoulesPerMole(double joulespermole)
+        public static MolarEnergy FromJoulesPerMole(double value)
         {
-            return new MolarEnergy(joulespermole, MolarEnergyUnit.JoulePerMole);
+            return new MolarEnergy(value, MolarEnergyUnit.JoulePerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.KilojoulePerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromKilojoulesPerMole(double kilojoulespermole)
+        public static MolarEnergy FromKilojoulesPerMole(double value)
         {
-            return new MolarEnergy(kilojoulespermole, MolarEnergyUnit.KilojoulePerMole);
+            return new MolarEnergy(value, MolarEnergyUnit.KilojoulePerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarEnergy"/> from <see cref="MolarEnergyUnit.MegajoulePerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEnergy FromMegajoulesPerMole(double megajoulespermole)
+        public static MolarEnergy FromMegajoulesPerMole(double value)
         {
-            return new MolarEnergy(megajoulespermole, MolarEnergyUnit.MegajoulePerMole);
+            return new MolarEnergy(value, MolarEnergyUnit.MegajoulePerMole);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
index b03a52aa8b..e1c0049a88 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarEntropy.g.cs
@@ -237,27 +237,27 @@ public static string GetAbbreviation(MolarEntropyUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.JoulePerMoleKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromJoulesPerMoleKelvin(double joulespermolekelvin)
+        public static MolarEntropy FromJoulesPerMoleKelvin(double value)
         {
-            return new MolarEntropy(joulespermolekelvin, MolarEntropyUnit.JoulePerMoleKelvin);
+            return new MolarEntropy(value, MolarEntropyUnit.JoulePerMoleKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.KilojoulePerMoleKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromKilojoulesPerMoleKelvin(double kilojoulespermolekelvin)
+        public static MolarEntropy FromKilojoulesPerMoleKelvin(double value)
         {
-            return new MolarEntropy(kilojoulespermolekelvin, MolarEntropyUnit.KilojoulePerMoleKelvin);
+            return new MolarEntropy(value, MolarEntropyUnit.KilojoulePerMoleKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarEntropy"/> from <see cref="MolarEntropyUnit.MegajoulePerMoleKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarEntropy FromMegajoulesPerMoleKelvin(double megajoulespermolekelvin)
+        public static MolarEntropy FromMegajoulesPerMoleKelvin(double value)
         {
-            return new MolarEntropy(megajoulespermolekelvin, MolarEntropyUnit.MegajoulePerMoleKelvin);
+            return new MolarEntropy(value, MolarEntropyUnit.MegajoulePerMoleKelvin);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
index 0dd64967c2..52d7f13d6f 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarFlow.g.cs
@@ -294,81 +294,81 @@ public static string GetAbbreviation(MolarFlowUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromKilomolesPerHour(double kilomolesperhour)
+        public static MolarFlow FromKilomolesPerHour(double value)
         {
-            return new MolarFlow(kilomolesperhour, MolarFlowUnit.KilomolePerHour);
+            return new MolarFlow(value, MolarFlowUnit.KilomolePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromKilomolesPerMinute(double kilomolesperminute)
+        public static MolarFlow FromKilomolesPerMinute(double value)
         {
-            return new MolarFlow(kilomolesperminute, MolarFlowUnit.KilomolePerMinute);
+            return new MolarFlow(value, MolarFlowUnit.KilomolePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.KilomolePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromKilomolesPerSecond(double kilomolespersecond)
+        public static MolarFlow FromKilomolesPerSecond(double value)
         {
-            return new MolarFlow(kilomolespersecond, MolarFlowUnit.KilomolePerSecond);
+            return new MolarFlow(value, MolarFlowUnit.KilomolePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromMolesPerHour(double molesperhour)
+        public static MolarFlow FromMolesPerHour(double value)
         {
-            return new MolarFlow(molesperhour, MolarFlowUnit.MolePerHour);
+            return new MolarFlow(value, MolarFlowUnit.MolePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromMolesPerMinute(double molesperminute)
+        public static MolarFlow FromMolesPerMinute(double value)
         {
-            return new MolarFlow(molesperminute, MolarFlowUnit.MolePerMinute);
+            return new MolarFlow(value, MolarFlowUnit.MolePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.MolePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromMolesPerSecond(double molespersecond)
+        public static MolarFlow FromMolesPerSecond(double value)
         {
-            return new MolarFlow(molespersecond, MolarFlowUnit.MolePerSecond);
+            return new MolarFlow(value, MolarFlowUnit.MolePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromPoundMolesPerHour(double poundmolesperhour)
+        public static MolarFlow FromPoundMolesPerHour(double value)
         {
-            return new MolarFlow(poundmolesperhour, MolarFlowUnit.PoundMolePerHour);
+            return new MolarFlow(value, MolarFlowUnit.PoundMolePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromPoundMolesPerMinute(double poundmolesperminute)
+        public static MolarFlow FromPoundMolesPerMinute(double value)
         {
-            return new MolarFlow(poundmolesperminute, MolarFlowUnit.PoundMolePerMinute);
+            return new MolarFlow(value, MolarFlowUnit.PoundMolePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarFlow"/> from <see cref="MolarFlowUnit.PoundMolePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarFlow FromPoundMolesPerSecond(double poundmolespersecond)
+        public static MolarFlow FromPoundMolesPerSecond(double value)
         {
-            return new MolarFlow(poundmolespersecond, MolarFlowUnit.PoundMolePerSecond);
+            return new MolarFlow(value, MolarFlowUnit.PoundMolePerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
index 3bfbb57fd7..d7b7d6696a 100644
--- a/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MolarMass.g.cs
@@ -325,117 +325,117 @@ public static string GetAbbreviation(MolarMassUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.CentigramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromCentigramsPerMole(double centigramspermole)
+        public static MolarMass FromCentigramsPerMole(double value)
         {
-            return new MolarMass(centigramspermole, MolarMassUnit.CentigramPerMole);
+            return new MolarMass(value, MolarMassUnit.CentigramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.DecagramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromDecagramsPerMole(double decagramspermole)
+        public static MolarMass FromDecagramsPerMole(double value)
         {
-            return new MolarMass(decagramspermole, MolarMassUnit.DecagramPerMole);
+            return new MolarMass(value, MolarMassUnit.DecagramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.DecigramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromDecigramsPerMole(double decigramspermole)
+        public static MolarMass FromDecigramsPerMole(double value)
         {
-            return new MolarMass(decigramspermole, MolarMassUnit.DecigramPerMole);
+            return new MolarMass(value, MolarMassUnit.DecigramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.GramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromGramsPerMole(double gramspermole)
+        public static MolarMass FromGramsPerMole(double value)
         {
-            return new MolarMass(gramspermole, MolarMassUnit.GramPerMole);
+            return new MolarMass(value, MolarMassUnit.GramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.HectogramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromHectogramsPerMole(double hectogramspermole)
+        public static MolarMass FromHectogramsPerMole(double value)
         {
-            return new MolarMass(hectogramspermole, MolarMassUnit.HectogramPerMole);
+            return new MolarMass(value, MolarMassUnit.HectogramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilogramPerKilomole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromKilogramsPerKilomole(double kilogramsperkilomole)
+        public static MolarMass FromKilogramsPerKilomole(double value)
         {
-            return new MolarMass(kilogramsperkilomole, MolarMassUnit.KilogramPerKilomole);
+            return new MolarMass(value, MolarMassUnit.KilogramPerKilomole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilogramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromKilogramsPerMole(double kilogramspermole)
+        public static MolarMass FromKilogramsPerMole(double value)
         {
-            return new MolarMass(kilogramspermole, MolarMassUnit.KilogramPerMole);
+            return new MolarMass(value, MolarMassUnit.KilogramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.KilopoundPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromKilopoundsPerMole(double kilopoundspermole)
+        public static MolarMass FromKilopoundsPerMole(double value)
         {
-            return new MolarMass(kilopoundspermole, MolarMassUnit.KilopoundPerMole);
+            return new MolarMass(value, MolarMassUnit.KilopoundPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MegapoundPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMegapoundsPerMole(double megapoundspermole)
+        public static MolarMass FromMegapoundsPerMole(double value)
         {
-            return new MolarMass(megapoundspermole, MolarMassUnit.MegapoundPerMole);
+            return new MolarMass(value, MolarMassUnit.MegapoundPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MicrogramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMicrogramsPerMole(double microgramspermole)
+        public static MolarMass FromMicrogramsPerMole(double value)
         {
-            return new MolarMass(microgramspermole, MolarMassUnit.MicrogramPerMole);
+            return new MolarMass(value, MolarMassUnit.MicrogramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.MilligramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromMilligramsPerMole(double milligramspermole)
+        public static MolarMass FromMilligramsPerMole(double value)
         {
-            return new MolarMass(milligramspermole, MolarMassUnit.MilligramPerMole);
+            return new MolarMass(value, MolarMassUnit.MilligramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.NanogramPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromNanogramsPerMole(double nanogramspermole)
+        public static MolarMass FromNanogramsPerMole(double value)
         {
-            return new MolarMass(nanogramspermole, MolarMassUnit.NanogramPerMole);
+            return new MolarMass(value, MolarMassUnit.NanogramPerMole);
         }
 
         /// <summary>
         ///     Creates a <see cref="MolarMass"/> from <see cref="MolarMassUnit.PoundPerMole"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static MolarMass FromPoundsPerMole(double poundspermole)
+        public static MolarMass FromPoundsPerMole(double value)
         {
-            return new MolarMass(poundspermole, MolarMassUnit.PoundPerMole);
+            return new MolarMass(value, MolarMassUnit.PoundPerMole);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
index 65c56868a3..7a1614b281 100644
--- a/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Molarity.g.cs
@@ -311,99 +311,99 @@ public static string GetAbbreviation(MolarityUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.CentimolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromCentimolesPerLiter(double centimolesperliter)
+        public static Molarity FromCentimolesPerLiter(double value)
         {
-            return new Molarity(centimolesperliter, MolarityUnit.CentimolePerLiter);
+            return new Molarity(value, MolarityUnit.CentimolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.DecimolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromDecimolesPerLiter(double decimolesperliter)
+        public static Molarity FromDecimolesPerLiter(double value)
         {
-            return new Molarity(decimolesperliter, MolarityUnit.DecimolePerLiter);
+            return new Molarity(value, MolarityUnit.DecimolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.FemtomolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromFemtomolesPerLiter(double femtomolesperliter)
+        public static Molarity FromFemtomolesPerLiter(double value)
         {
-            return new Molarity(femtomolesperliter, MolarityUnit.FemtomolePerLiter);
+            return new Molarity(value, MolarityUnit.FemtomolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.KilomolePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromKilomolesPerCubicMeter(double kilomolespercubicmeter)
+        public static Molarity FromKilomolesPerCubicMeter(double value)
         {
-            return new Molarity(kilomolespercubicmeter, MolarityUnit.KilomolePerCubicMeter);
+            return new Molarity(value, MolarityUnit.KilomolePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MicromolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMicromolesPerLiter(double micromolesperliter)
+        public static Molarity FromMicromolesPerLiter(double value)
         {
-            return new Molarity(micromolesperliter, MolarityUnit.MicromolePerLiter);
+            return new Molarity(value, MolarityUnit.MicromolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MillimolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMillimolesPerLiter(double millimolesperliter)
+        public static Molarity FromMillimolesPerLiter(double value)
         {
-            return new Molarity(millimolesperliter, MolarityUnit.MillimolePerLiter);
+            return new Molarity(value, MolarityUnit.MillimolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MolePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMolesPerCubicMeter(double molespercubicmeter)
+        public static Molarity FromMolesPerCubicMeter(double value)
         {
-            return new Molarity(molespercubicmeter, MolarityUnit.MolePerCubicMeter);
+            return new Molarity(value, MolarityUnit.MolePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.MolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromMolesPerLiter(double molesperliter)
+        public static Molarity FromMolesPerLiter(double value)
         {
-            return new Molarity(molesperliter, MolarityUnit.MolePerLiter);
+            return new Molarity(value, MolarityUnit.MolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.NanomolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromNanomolesPerLiter(double nanomolesperliter)
+        public static Molarity FromNanomolesPerLiter(double value)
         {
-            return new Molarity(nanomolesperliter, MolarityUnit.NanomolePerLiter);
+            return new Molarity(value, MolarityUnit.NanomolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.PicomolePerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromPicomolesPerLiter(double picomolesperliter)
+        public static Molarity FromPicomolesPerLiter(double value)
         {
-            return new Molarity(picomolesperliter, MolarityUnit.PicomolePerLiter);
+            return new Molarity(value, MolarityUnit.PicomolePerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Molarity"/> from <see cref="MolarityUnit.PoundMolePerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Molarity FromPoundMolesPerCubicFoot(double poundmolespercubicfoot)
+        public static Molarity FromPoundMolesPerCubicFoot(double value)
         {
-            return new Molarity(poundmolespercubicfoot, MolarityUnit.PoundMolePerCubicFoot);
+            return new Molarity(value, MolarityUnit.PoundMolePerCubicFoot);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
index 127dee07c2..0220349934 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permeability.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(PermeabilityUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="Permeability"/> from <see cref="PermeabilityUnit.HenryPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Permeability FromHenriesPerMeter(double henriespermeter)
+        public static Permeability FromHenriesPerMeter(double value)
         {
-            return new Permeability(henriespermeter, PermeabilityUnit.HenryPerMeter);
+            return new Permeability(value, PermeabilityUnit.HenryPerMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
index 0695207fde..9893ff11a7 100644
--- a/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Permittivity.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(PermittivityUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="Permittivity"/> from <see cref="PermittivityUnit.FaradPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Permittivity FromFaradsPerMeter(double faradspermeter)
+        public static Permittivity FromFaradsPerMeter(double value)
         {
-            return new Permittivity(faradspermeter, PermittivityUnit.FaradPerMeter);
+            return new Permittivity(value, PermittivityUnit.FaradPerMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs b/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
index 797b6278c8..7317201cad 100644
--- a/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PorousMediumPermeability.g.cs
@@ -256,45 +256,45 @@ public static string GetAbbreviation(PorousMediumPermeabilityUnit unit, IFormatP
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Darcy"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromDarcys(double darcys)
+        public static PorousMediumPermeability FromDarcys(double value)
         {
-            return new PorousMediumPermeability(darcys, PorousMediumPermeabilityUnit.Darcy);
+            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Darcy);
         }
 
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Microdarcy"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromMicrodarcys(double microdarcys)
+        public static PorousMediumPermeability FromMicrodarcys(double value)
         {
-            return new PorousMediumPermeability(microdarcys, PorousMediumPermeabilityUnit.Microdarcy);
+            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Microdarcy);
         }
 
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.Millidarcy"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromMillidarcys(double millidarcys)
+        public static PorousMediumPermeability FromMillidarcys(double value)
         {
-            return new PorousMediumPermeability(millidarcys, PorousMediumPermeabilityUnit.Millidarcy);
+            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.Millidarcy);
         }
 
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.SquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromSquareCentimeters(double squarecentimeters)
+        public static PorousMediumPermeability FromSquareCentimeters(double value)
         {
-            return new PorousMediumPermeability(squarecentimeters, PorousMediumPermeabilityUnit.SquareCentimeter);
+            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.SquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PorousMediumPermeability"/> from <see cref="PorousMediumPermeabilityUnit.SquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PorousMediumPermeability FromSquareMeters(double squaremeters)
+        public static PorousMediumPermeability FromSquareMeters(double value)
         {
-            return new PorousMediumPermeability(squaremeters, PorousMediumPermeabilityUnit.SquareMeter);
+            return new PorousMediumPermeability(value, PorousMediumPermeabilityUnit.SquareMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Power.g.cs b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
index aea66bf0d1..186f60ad34 100644
--- a/UnitsNet/GeneratedCode/Quantities/Power.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Power.g.cs
@@ -438,234 +438,234 @@ public static string GetAbbreviation(PowerUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.BoilerHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromBoilerHorsepower(double boilerhorsepower)
+        public static Power FromBoilerHorsepower(double value)
         {
-            return new Power(boilerhorsepower, PowerUnit.BoilerHorsepower);
+            return new Power(value, PowerUnit.BoilerHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.BritishThermalUnitPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromBritishThermalUnitsPerHour(double britishthermalunitsperhour)
+        public static Power FromBritishThermalUnitsPerHour(double value)
         {
-            return new Power(britishthermalunitsperhour, PowerUnit.BritishThermalUnitPerHour);
+            return new Power(value, PowerUnit.BritishThermalUnitPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Decawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromDecawatts(double decawatts)
+        public static Power FromDecawatts(double value)
         {
-            return new Power(decawatts, PowerUnit.Decawatt);
+            return new Power(value, PowerUnit.Decawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Deciwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromDeciwatts(double deciwatts)
+        public static Power FromDeciwatts(double value)
         {
-            return new Power(deciwatts, PowerUnit.Deciwatt);
+            return new Power(value, PowerUnit.Deciwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.ElectricalHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromElectricalHorsepower(double electricalhorsepower)
+        public static Power FromElectricalHorsepower(double value)
         {
-            return new Power(electricalhorsepower, PowerUnit.ElectricalHorsepower);
+            return new Power(value, PowerUnit.ElectricalHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Femtowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromFemtowatts(double femtowatts)
+        public static Power FromFemtowatts(double value)
         {
-            return new Power(femtowatts, PowerUnit.Femtowatt);
+            return new Power(value, PowerUnit.Femtowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.GigajoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromGigajoulesPerHour(double gigajoulesperhour)
+        public static Power FromGigajoulesPerHour(double value)
         {
-            return new Power(gigajoulesperhour, PowerUnit.GigajoulePerHour);
+            return new Power(value, PowerUnit.GigajoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Gigawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromGigawatts(double gigawatts)
+        public static Power FromGigawatts(double value)
         {
-            return new Power(gigawatts, PowerUnit.Gigawatt);
+            return new Power(value, PowerUnit.Gigawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.HydraulicHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromHydraulicHorsepower(double hydraulichorsepower)
+        public static Power FromHydraulicHorsepower(double value)
         {
-            return new Power(hydraulichorsepower, PowerUnit.HydraulicHorsepower);
+            return new Power(value, PowerUnit.HydraulicHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.JoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromJoulesPerHour(double joulesperhour)
+        public static Power FromJoulesPerHour(double value)
         {
-            return new Power(joulesperhour, PowerUnit.JoulePerHour);
+            return new Power(value, PowerUnit.JoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.KilobritishThermalUnitPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilobritishThermalUnitsPerHour(double kilobritishthermalunitsperhour)
+        public static Power FromKilobritishThermalUnitsPerHour(double value)
         {
-            return new Power(kilobritishthermalunitsperhour, PowerUnit.KilobritishThermalUnitPerHour);
+            return new Power(value, PowerUnit.KilobritishThermalUnitPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.KilojoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilojoulesPerHour(double kilojoulesperhour)
+        public static Power FromKilojoulesPerHour(double value)
         {
-            return new Power(kilojoulesperhour, PowerUnit.KilojoulePerHour);
+            return new Power(value, PowerUnit.KilojoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Kilowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromKilowatts(double kilowatts)
+        public static Power FromKilowatts(double value)
         {
-            return new Power(kilowatts, PowerUnit.Kilowatt);
+            return new Power(value, PowerUnit.Kilowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MechanicalHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMechanicalHorsepower(double mechanicalhorsepower)
+        public static Power FromMechanicalHorsepower(double value)
         {
-            return new Power(mechanicalhorsepower, PowerUnit.MechanicalHorsepower);
+            return new Power(value, PowerUnit.MechanicalHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MegabritishThermalUnitPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMegabritishThermalUnitsPerHour(double megabritishthermalunitsperhour)
+        public static Power FromMegabritishThermalUnitsPerHour(double value)
         {
-            return new Power(megabritishthermalunitsperhour, PowerUnit.MegabritishThermalUnitPerHour);
+            return new Power(value, PowerUnit.MegabritishThermalUnitPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MegajoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMegajoulesPerHour(double megajoulesperhour)
+        public static Power FromMegajoulesPerHour(double value)
         {
-            return new Power(megajoulesperhour, PowerUnit.MegajoulePerHour);
+            return new Power(value, PowerUnit.MegajoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Megawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMegawatts(double megawatts)
+        public static Power FromMegawatts(double value)
         {
-            return new Power(megawatts, PowerUnit.Megawatt);
+            return new Power(value, PowerUnit.Megawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MetricHorsepower"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMetricHorsepower(double metrichorsepower)
+        public static Power FromMetricHorsepower(double value)
         {
-            return new Power(metrichorsepower, PowerUnit.MetricHorsepower);
+            return new Power(value, PowerUnit.MetricHorsepower);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Microwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMicrowatts(double microwatts)
+        public static Power FromMicrowatts(double value)
         {
-            return new Power(microwatts, PowerUnit.Microwatt);
+            return new Power(value, PowerUnit.Microwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.MillijoulePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMillijoulesPerHour(double millijoulesperhour)
+        public static Power FromMillijoulesPerHour(double value)
         {
-            return new Power(millijoulesperhour, PowerUnit.MillijoulePerHour);
+            return new Power(value, PowerUnit.MillijoulePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Milliwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromMilliwatts(double milliwatts)
+        public static Power FromMilliwatts(double value)
         {
-            return new Power(milliwatts, PowerUnit.Milliwatt);
+            return new Power(value, PowerUnit.Milliwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Nanowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromNanowatts(double nanowatts)
+        public static Power FromNanowatts(double value)
         {
-            return new Power(nanowatts, PowerUnit.Nanowatt);
+            return new Power(value, PowerUnit.Nanowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Petawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromPetawatts(double petawatts)
+        public static Power FromPetawatts(double value)
         {
-            return new Power(petawatts, PowerUnit.Petawatt);
+            return new Power(value, PowerUnit.Petawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Picowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromPicowatts(double picowatts)
+        public static Power FromPicowatts(double value)
         {
-            return new Power(picowatts, PowerUnit.Picowatt);
+            return new Power(value, PowerUnit.Picowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Terawatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromTerawatts(double terawatts)
+        public static Power FromTerawatts(double value)
         {
-            return new Power(terawatts, PowerUnit.Terawatt);
+            return new Power(value, PowerUnit.Terawatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="Power"/> from <see cref="PowerUnit.Watt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Power FromWatts(double watts)
+        public static Power FromWatts(double value)
         {
-            return new Power(watts, PowerUnit.Watt);
+            return new Power(value, PowerUnit.Watt);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
index 22731dc022..f28f92ed39 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerDensity.g.cs
@@ -565,396 +565,396 @@ public static string GetAbbreviation(PowerDensityUnit unit, IFormatProvider? pro
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicFoot(double decawattspercubicfoot)
+        public static PowerDensity FromDecawattsPerCubicFoot(double value)
         {
-            return new PowerDensity(decawattspercubicfoot, PowerDensityUnit.DecawattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicInch(double decawattspercubicinch)
+        public static PowerDensity FromDecawattsPerCubicInch(double value)
         {
-            return new PowerDensity(decawattspercubicinch, PowerDensityUnit.DecawattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerCubicMeter(double decawattspercubicmeter)
+        public static PowerDensity FromDecawattsPerCubicMeter(double value)
         {
-            return new PowerDensity(decawattspercubicmeter, PowerDensityUnit.DecawattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.DecawattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DecawattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDecawattsPerLiter(double decawattsperliter)
+        public static PowerDensity FromDecawattsPerLiter(double value)
         {
-            return new PowerDensity(decawattsperliter, PowerDensityUnit.DecawattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.DecawattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicFoot(double deciwattspercubicfoot)
+        public static PowerDensity FromDeciwattsPerCubicFoot(double value)
         {
-            return new PowerDensity(deciwattspercubicfoot, PowerDensityUnit.DeciwattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicInch(double deciwattspercubicinch)
+        public static PowerDensity FromDeciwattsPerCubicInch(double value)
         {
-            return new PowerDensity(deciwattspercubicinch, PowerDensityUnit.DeciwattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerCubicMeter(double deciwattspercubicmeter)
+        public static PowerDensity FromDeciwattsPerCubicMeter(double value)
         {
-            return new PowerDensity(deciwattspercubicmeter, PowerDensityUnit.DeciwattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.DeciwattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.DeciwattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromDeciwattsPerLiter(double deciwattsperliter)
+        public static PowerDensity FromDeciwattsPerLiter(double value)
         {
-            return new PowerDensity(deciwattsperliter, PowerDensityUnit.DeciwattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.DeciwattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicFoot(double gigawattspercubicfoot)
+        public static PowerDensity FromGigawattsPerCubicFoot(double value)
         {
-            return new PowerDensity(gigawattspercubicfoot, PowerDensityUnit.GigawattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicInch(double gigawattspercubicinch)
+        public static PowerDensity FromGigawattsPerCubicInch(double value)
         {
-            return new PowerDensity(gigawattspercubicinch, PowerDensityUnit.GigawattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerCubicMeter(double gigawattspercubicmeter)
+        public static PowerDensity FromGigawattsPerCubicMeter(double value)
         {
-            return new PowerDensity(gigawattspercubicmeter, PowerDensityUnit.GigawattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.GigawattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.GigawattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromGigawattsPerLiter(double gigawattsperliter)
+        public static PowerDensity FromGigawattsPerLiter(double value)
         {
-            return new PowerDensity(gigawattsperliter, PowerDensityUnit.GigawattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.GigawattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicFoot(double kilowattspercubicfoot)
+        public static PowerDensity FromKilowattsPerCubicFoot(double value)
         {
-            return new PowerDensity(kilowattspercubicfoot, PowerDensityUnit.KilowattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicInch(double kilowattspercubicinch)
+        public static PowerDensity FromKilowattsPerCubicInch(double value)
         {
-            return new PowerDensity(kilowattspercubicinch, PowerDensityUnit.KilowattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerCubicMeter(double kilowattspercubicmeter)
+        public static PowerDensity FromKilowattsPerCubicMeter(double value)
         {
-            return new PowerDensity(kilowattspercubicmeter, PowerDensityUnit.KilowattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.KilowattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.KilowattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromKilowattsPerLiter(double kilowattsperliter)
+        public static PowerDensity FromKilowattsPerLiter(double value)
         {
-            return new PowerDensity(kilowattsperliter, PowerDensityUnit.KilowattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.KilowattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicFoot(double megawattspercubicfoot)
+        public static PowerDensity FromMegawattsPerCubicFoot(double value)
         {
-            return new PowerDensity(megawattspercubicfoot, PowerDensityUnit.MegawattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicInch(double megawattspercubicinch)
+        public static PowerDensity FromMegawattsPerCubicInch(double value)
         {
-            return new PowerDensity(megawattspercubicinch, PowerDensityUnit.MegawattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerCubicMeter(double megawattspercubicmeter)
+        public static PowerDensity FromMegawattsPerCubicMeter(double value)
         {
-            return new PowerDensity(megawattspercubicmeter, PowerDensityUnit.MegawattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.MegawattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MegawattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMegawattsPerLiter(double megawattsperliter)
+        public static PowerDensity FromMegawattsPerLiter(double value)
         {
-            return new PowerDensity(megawattsperliter, PowerDensityUnit.MegawattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.MegawattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicFoot(double microwattspercubicfoot)
+        public static PowerDensity FromMicrowattsPerCubicFoot(double value)
         {
-            return new PowerDensity(microwattspercubicfoot, PowerDensityUnit.MicrowattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicInch(double microwattspercubicinch)
+        public static PowerDensity FromMicrowattsPerCubicInch(double value)
         {
-            return new PowerDensity(microwattspercubicinch, PowerDensityUnit.MicrowattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerCubicMeter(double microwattspercubicmeter)
+        public static PowerDensity FromMicrowattsPerCubicMeter(double value)
         {
-            return new PowerDensity(microwattspercubicmeter, PowerDensityUnit.MicrowattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.MicrowattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MicrowattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMicrowattsPerLiter(double microwattsperliter)
+        public static PowerDensity FromMicrowattsPerLiter(double value)
         {
-            return new PowerDensity(microwattsperliter, PowerDensityUnit.MicrowattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.MicrowattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicFoot(double milliwattspercubicfoot)
+        public static PowerDensity FromMilliwattsPerCubicFoot(double value)
         {
-            return new PowerDensity(milliwattspercubicfoot, PowerDensityUnit.MilliwattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicInch(double milliwattspercubicinch)
+        public static PowerDensity FromMilliwattsPerCubicInch(double value)
         {
-            return new PowerDensity(milliwattspercubicinch, PowerDensityUnit.MilliwattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerCubicMeter(double milliwattspercubicmeter)
+        public static PowerDensity FromMilliwattsPerCubicMeter(double value)
         {
-            return new PowerDensity(milliwattspercubicmeter, PowerDensityUnit.MilliwattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.MilliwattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.MilliwattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromMilliwattsPerLiter(double milliwattsperliter)
+        public static PowerDensity FromMilliwattsPerLiter(double value)
         {
-            return new PowerDensity(milliwattsperliter, PowerDensityUnit.MilliwattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.MilliwattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicFoot(double nanowattspercubicfoot)
+        public static PowerDensity FromNanowattsPerCubicFoot(double value)
         {
-            return new PowerDensity(nanowattspercubicfoot, PowerDensityUnit.NanowattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicInch(double nanowattspercubicinch)
+        public static PowerDensity FromNanowattsPerCubicInch(double value)
         {
-            return new PowerDensity(nanowattspercubicinch, PowerDensityUnit.NanowattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerCubicMeter(double nanowattspercubicmeter)
+        public static PowerDensity FromNanowattsPerCubicMeter(double value)
         {
-            return new PowerDensity(nanowattspercubicmeter, PowerDensityUnit.NanowattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.NanowattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.NanowattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromNanowattsPerLiter(double nanowattsperliter)
+        public static PowerDensity FromNanowattsPerLiter(double value)
         {
-            return new PowerDensity(nanowattsperliter, PowerDensityUnit.NanowattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.NanowattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicFoot(double picowattspercubicfoot)
+        public static PowerDensity FromPicowattsPerCubicFoot(double value)
         {
-            return new PowerDensity(picowattspercubicfoot, PowerDensityUnit.PicowattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicInch(double picowattspercubicinch)
+        public static PowerDensity FromPicowattsPerCubicInch(double value)
         {
-            return new PowerDensity(picowattspercubicinch, PowerDensityUnit.PicowattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerCubicMeter(double picowattspercubicmeter)
+        public static PowerDensity FromPicowattsPerCubicMeter(double value)
         {
-            return new PowerDensity(picowattspercubicmeter, PowerDensityUnit.PicowattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.PicowattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.PicowattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromPicowattsPerLiter(double picowattsperliter)
+        public static PowerDensity FromPicowattsPerLiter(double value)
         {
-            return new PowerDensity(picowattsperliter, PowerDensityUnit.PicowattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.PicowattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicFoot(double terawattspercubicfoot)
+        public static PowerDensity FromTerawattsPerCubicFoot(double value)
         {
-            return new PowerDensity(terawattspercubicfoot, PowerDensityUnit.TerawattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicInch(double terawattspercubicinch)
+        public static PowerDensity FromTerawattsPerCubicInch(double value)
         {
-            return new PowerDensity(terawattspercubicinch, PowerDensityUnit.TerawattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerCubicMeter(double terawattspercubicmeter)
+        public static PowerDensity FromTerawattsPerCubicMeter(double value)
         {
-            return new PowerDensity(terawattspercubicmeter, PowerDensityUnit.TerawattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.TerawattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.TerawattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromTerawattsPerLiter(double terawattsperliter)
+        public static PowerDensity FromTerawattsPerLiter(double value)
         {
-            return new PowerDensity(terawattsperliter, PowerDensityUnit.TerawattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.TerawattPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicFoot(double wattspercubicfoot)
+        public static PowerDensity FromWattsPerCubicFoot(double value)
         {
-            return new PowerDensity(wattspercubicfoot, PowerDensityUnit.WattPerCubicFoot);
+            return new PowerDensity(value, PowerDensityUnit.WattPerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicInch(double wattspercubicinch)
+        public static PowerDensity FromWattsPerCubicInch(double value)
         {
-            return new PowerDensity(wattspercubicinch, PowerDensityUnit.WattPerCubicInch);
+            return new PowerDensity(value, PowerDensityUnit.WattPerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerCubicMeter(double wattspercubicmeter)
+        public static PowerDensity FromWattsPerCubicMeter(double value)
         {
-            return new PowerDensity(wattspercubicmeter, PowerDensityUnit.WattPerCubicMeter);
+            return new PowerDensity(value, PowerDensityUnit.WattPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerDensity"/> from <see cref="PowerDensityUnit.WattPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerDensity FromWattsPerLiter(double wattsperliter)
+        public static PowerDensity FromWattsPerLiter(double value)
         {
-            return new PowerDensity(wattsperliter, PowerDensityUnit.WattPerLiter);
+            return new PowerDensity(value, PowerDensityUnit.WattPerLiter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
index 32d914c432..135515997d 100644
--- a/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PowerRatio.g.cs
@@ -229,18 +229,18 @@ public static string GetAbbreviation(PowerRatioUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="PowerRatio"/> from <see cref="PowerRatioUnit.DecibelMilliwatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerRatio FromDecibelMilliwatts(double decibelmilliwatts)
+        public static PowerRatio FromDecibelMilliwatts(double value)
         {
-            return new PowerRatio(decibelmilliwatts, PowerRatioUnit.DecibelMilliwatt);
+            return new PowerRatio(value, PowerRatioUnit.DecibelMilliwatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="PowerRatio"/> from <see cref="PowerRatioUnit.DecibelWatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PowerRatio FromDecibelWatts(double decibelwatts)
+        public static PowerRatio FromDecibelWatts(double value)
         {
-            return new PowerRatio(decibelwatts, PowerRatioUnit.DecibelWatt);
+            return new PowerRatio(value, PowerRatioUnit.DecibelWatt);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
index a0c06f2a49..cc8e6aa4d4 100644
--- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
@@ -617,441 +617,441 @@ public static string GetAbbreviation(PressureUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Atmosphere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromAtmospheres(double atmospheres)
+        public static Pressure FromAtmospheres(double value)
         {
-            return new Pressure(atmospheres, PressureUnit.Atmosphere);
+            return new Pressure(value, PressureUnit.Atmosphere);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Bar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromBars(double bars)
+        public static Pressure FromBars(double value)
         {
-            return new Pressure(bars, PressureUnit.Bar);
+            return new Pressure(value, PressureUnit.Bar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Centibar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromCentibars(double centibars)
+        public static Pressure FromCentibars(double value)
         {
-            return new Pressure(centibars, PressureUnit.Centibar);
+            return new Pressure(value, PressureUnit.Centibar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.CentimeterOfWaterColumn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromCentimetersOfWaterColumn(double centimetersofwatercolumn)
+        public static Pressure FromCentimetersOfWaterColumn(double value)
         {
-            return new Pressure(centimetersofwatercolumn, PressureUnit.CentimeterOfWaterColumn);
+            return new Pressure(value, PressureUnit.CentimeterOfWaterColumn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Decapascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDecapascals(double decapascals)
+        public static Pressure FromDecapascals(double value)
         {
-            return new Pressure(decapascals, PressureUnit.Decapascal);
+            return new Pressure(value, PressureUnit.Decapascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Decibar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDecibars(double decibars)
+        public static Pressure FromDecibars(double value)
         {
-            return new Pressure(decibars, PressureUnit.Decibar);
+            return new Pressure(value, PressureUnit.Decibar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.DynePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromDynesPerSquareCentimeter(double dynespersquarecentimeter)
+        public static Pressure FromDynesPerSquareCentimeter(double value)
         {
-            return new Pressure(dynespersquarecentimeter, PressureUnit.DynePerSquareCentimeter);
+            return new Pressure(value, PressureUnit.DynePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.FootOfElevation"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromFeetOfElevation(double feetofelevation)
+        public static Pressure FromFeetOfElevation(double value)
         {
-            return new Pressure(feetofelevation, PressureUnit.FootOfElevation);
+            return new Pressure(value, PressureUnit.FootOfElevation);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.FootOfHead"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromFeetOfHead(double feetofhead)
+        public static Pressure FromFeetOfHead(double value)
         {
-            return new Pressure(feetofhead, PressureUnit.FootOfHead);
+            return new Pressure(value, PressureUnit.FootOfHead);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Gigapascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromGigapascals(double gigapascals)
+        public static Pressure FromGigapascals(double value)
         {
-            return new Pressure(gigapascals, PressureUnit.Gigapascal);
+            return new Pressure(value, PressureUnit.Gigapascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Hectopascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromHectopascals(double hectopascals)
+        public static Pressure FromHectopascals(double value)
         {
-            return new Pressure(hectopascals, PressureUnit.Hectopascal);
+            return new Pressure(value, PressureUnit.Hectopascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.InchOfMercury"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromInchesOfMercury(double inchesofmercury)
+        public static Pressure FromInchesOfMercury(double value)
         {
-            return new Pressure(inchesofmercury, PressureUnit.InchOfMercury);
+            return new Pressure(value, PressureUnit.InchOfMercury);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.InchOfWaterColumn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromInchesOfWaterColumn(double inchesofwatercolumn)
+        public static Pressure FromInchesOfWaterColumn(double value)
         {
-            return new Pressure(inchesofwatercolumn, PressureUnit.InchOfWaterColumn);
+            return new Pressure(value, PressureUnit.InchOfWaterColumn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Kilobar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilobars(double kilobars)
+        public static Pressure FromKilobars(double value)
         {
-            return new Pressure(kilobars, PressureUnit.Kilobar);
+            return new Pressure(value, PressureUnit.Kilobar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareCentimeter(double kilogramsforcepersquarecentimeter)
+        public static Pressure FromKilogramsForcePerSquareCentimeter(double value)
         {
-            return new Pressure(kilogramsforcepersquarecentimeter, PressureUnit.KilogramForcePerSquareCentimeter);
+            return new Pressure(value, PressureUnit.KilogramForcePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareMeter(double kilogramsforcepersquaremeter)
+        public static Pressure FromKilogramsForcePerSquareMeter(double value)
         {
-            return new Pressure(kilogramsforcepersquaremeter, PressureUnit.KilogramForcePerSquareMeter);
+            return new Pressure(value, PressureUnit.KilogramForcePerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilogramForcePerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilogramsForcePerSquareMillimeter(double kilogramsforcepersquaremillimeter)
+        public static Pressure FromKilogramsForcePerSquareMillimeter(double value)
         {
-            return new Pressure(kilogramsforcepersquaremillimeter, PressureUnit.KilogramForcePerSquareMillimeter);
+            return new Pressure(value, PressureUnit.KilogramForcePerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareCentimeter(double kilonewtonspersquarecentimeter)
+        public static Pressure FromKilonewtonsPerSquareCentimeter(double value)
         {
-            return new Pressure(kilonewtonspersquarecentimeter, PressureUnit.KilonewtonPerSquareCentimeter);
+            return new Pressure(value, PressureUnit.KilonewtonPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareMeter(double kilonewtonspersquaremeter)
+        public static Pressure FromKilonewtonsPerSquareMeter(double value)
         {
-            return new Pressure(kilonewtonspersquaremeter, PressureUnit.KilonewtonPerSquareMeter);
+            return new Pressure(value, PressureUnit.KilonewtonPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilonewtonPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilonewtonsPerSquareMillimeter(double kilonewtonspersquaremillimeter)
+        public static Pressure FromKilonewtonsPerSquareMillimeter(double value)
         {
-            return new Pressure(kilonewtonspersquaremillimeter, PressureUnit.KilonewtonPerSquareMillimeter);
+            return new Pressure(value, PressureUnit.KilonewtonPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Kilopascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopascals(double kilopascals)
+        public static Pressure FromKilopascals(double value)
         {
-            return new Pressure(kilopascals, PressureUnit.Kilopascal);
+            return new Pressure(value, PressureUnit.Kilopascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopoundsForcePerSquareFoot(double kilopoundsforcepersquarefoot)
+        public static Pressure FromKilopoundsForcePerSquareFoot(double value)
         {
-            return new Pressure(kilopoundsforcepersquarefoot, PressureUnit.KilopoundForcePerSquareFoot);
+            return new Pressure(value, PressureUnit.KilopoundForcePerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopoundsForcePerSquareInch(double kilopoundsforcepersquareinch)
+        public static Pressure FromKilopoundsForcePerSquareInch(double value)
         {
-            return new Pressure(kilopoundsforcepersquareinch, PressureUnit.KilopoundForcePerSquareInch);
+            return new Pressure(value, PressureUnit.KilopoundForcePerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.KilopoundForcePerSquareMil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromKilopoundsForcePerSquareMil(double kilopoundsforcepersquaremil)
+        public static Pressure FromKilopoundsForcePerSquareMil(double value)
         {
-            return new Pressure(kilopoundsforcepersquaremil, PressureUnit.KilopoundForcePerSquareMil);
+            return new Pressure(value, PressureUnit.KilopoundForcePerSquareMil);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Megabar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMegabars(double megabars)
+        public static Pressure FromMegabars(double value)
         {
-            return new Pressure(megabars, PressureUnit.Megabar);
+            return new Pressure(value, PressureUnit.Megabar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeganewtonPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMeganewtonsPerSquareMeter(double meganewtonspersquaremeter)
+        public static Pressure FromMeganewtonsPerSquareMeter(double value)
         {
-            return new Pressure(meganewtonspersquaremeter, PressureUnit.MeganewtonPerSquareMeter);
+            return new Pressure(value, PressureUnit.MeganewtonPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Megapascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMegapascals(double megapascals)
+        public static Pressure FromMegapascals(double value)
         {
-            return new Pressure(megapascals, PressureUnit.Megapascal);
+            return new Pressure(value, PressureUnit.Megapascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfElevation"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMetersOfElevation(double metersofelevation)
+        public static Pressure FromMetersOfElevation(double value)
         {
-            return new Pressure(metersofelevation, PressureUnit.MeterOfElevation);
+            return new Pressure(value, PressureUnit.MeterOfElevation);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfHead"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMetersOfHead(double metersofhead)
+        public static Pressure FromMetersOfHead(double value)
         {
-            return new Pressure(metersofhead, PressureUnit.MeterOfHead);
+            return new Pressure(value, PressureUnit.MeterOfHead);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MeterOfWaterColumn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMetersOfWaterColumn(double metersofwatercolumn)
+        public static Pressure FromMetersOfWaterColumn(double value)
         {
-            return new Pressure(metersofwatercolumn, PressureUnit.MeterOfWaterColumn);
+            return new Pressure(value, PressureUnit.MeterOfWaterColumn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Microbar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMicrobars(double microbars)
+        public static Pressure FromMicrobars(double value)
         {
-            return new Pressure(microbars, PressureUnit.Microbar);
+            return new Pressure(value, PressureUnit.Microbar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Micropascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMicropascals(double micropascals)
+        public static Pressure FromMicropascals(double value)
         {
-            return new Pressure(micropascals, PressureUnit.Micropascal);
+            return new Pressure(value, PressureUnit.Micropascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millibar"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillibars(double millibars)
+        public static Pressure FromMillibars(double value)
         {
-            return new Pressure(millibars, PressureUnit.Millibar);
+            return new Pressure(value, PressureUnit.Millibar);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MillimeterOfMercury"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillimetersOfMercury(double millimetersofmercury)
+        public static Pressure FromMillimetersOfMercury(double value)
         {
-            return new Pressure(millimetersofmercury, PressureUnit.MillimeterOfMercury);
+            return new Pressure(value, PressureUnit.MillimeterOfMercury);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.MillimeterOfWaterColumn"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillimetersOfWaterColumn(double millimetersofwatercolumn)
+        public static Pressure FromMillimetersOfWaterColumn(double value)
         {
-            return new Pressure(millimetersofwatercolumn, PressureUnit.MillimeterOfWaterColumn);
+            return new Pressure(value, PressureUnit.MillimeterOfWaterColumn);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Millipascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromMillipascals(double millipascals)
+        public static Pressure FromMillipascals(double value)
         {
-            return new Pressure(millipascals, PressureUnit.Millipascal);
+            return new Pressure(value, PressureUnit.Millipascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareCentimeter(double newtonspersquarecentimeter)
+        public static Pressure FromNewtonsPerSquareCentimeter(double value)
         {
-            return new Pressure(newtonspersquarecentimeter, PressureUnit.NewtonPerSquareCentimeter);
+            return new Pressure(value, PressureUnit.NewtonPerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareMeter(double newtonspersquaremeter)
+        public static Pressure FromNewtonsPerSquareMeter(double value)
         {
-            return new Pressure(newtonspersquaremeter, PressureUnit.NewtonPerSquareMeter);
+            return new Pressure(value, PressureUnit.NewtonPerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.NewtonPerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromNewtonsPerSquareMillimeter(double newtonspersquaremillimeter)
+        public static Pressure FromNewtonsPerSquareMillimeter(double value)
         {
-            return new Pressure(newtonspersquaremillimeter, PressureUnit.NewtonPerSquareMillimeter);
+            return new Pressure(value, PressureUnit.NewtonPerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Pascal"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPascals(double pascals)
+        public static Pressure FromPascals(double value)
         {
-            return new Pressure(pascals, PressureUnit.Pascal);
+            return new Pressure(value, PressureUnit.Pascal);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsForcePerSquareFoot(double poundsforcepersquarefoot)
+        public static Pressure FromPoundsForcePerSquareFoot(double value)
         {
-            return new Pressure(poundsforcepersquarefoot, PressureUnit.PoundForcePerSquareFoot);
+            return new Pressure(value, PressureUnit.PoundForcePerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsForcePerSquareInch(double poundsforcepersquareinch)
+        public static Pressure FromPoundsForcePerSquareInch(double value)
         {
-            return new Pressure(poundsforcepersquareinch, PressureUnit.PoundForcePerSquareInch);
+            return new Pressure(value, PressureUnit.PoundForcePerSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundForcePerSquareMil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsForcePerSquareMil(double poundsforcepersquaremil)
+        public static Pressure FromPoundsForcePerSquareMil(double value)
         {
-            return new Pressure(poundsforcepersquaremil, PressureUnit.PoundForcePerSquareMil);
+            return new Pressure(value, PressureUnit.PoundForcePerSquareMil);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.PoundPerInchSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromPoundsPerInchSecondSquared(double poundsperinchsecondsquared)
+        public static Pressure FromPoundsPerInchSecondSquared(double value)
         {
-            return new Pressure(poundsperinchsecondsquared, PressureUnit.PoundPerInchSecondSquared);
+            return new Pressure(value, PressureUnit.PoundPerInchSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TechnicalAtmosphere"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTechnicalAtmospheres(double technicalatmospheres)
+        public static Pressure FromTechnicalAtmospheres(double value)
         {
-            return new Pressure(technicalatmospheres, PressureUnit.TechnicalAtmosphere);
+            return new Pressure(value, PressureUnit.TechnicalAtmosphere);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareCentimeter(double tonnesforcepersquarecentimeter)
+        public static Pressure FromTonnesForcePerSquareCentimeter(double value)
         {
-            return new Pressure(tonnesforcepersquarecentimeter, PressureUnit.TonneForcePerSquareCentimeter);
+            return new Pressure(value, PressureUnit.TonneForcePerSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareMeter(double tonnesforcepersquaremeter)
+        public static Pressure FromTonnesForcePerSquareMeter(double value)
         {
-            return new Pressure(tonnesforcepersquaremeter, PressureUnit.TonneForcePerSquareMeter);
+            return new Pressure(value, PressureUnit.TonneForcePerSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.TonneForcePerSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTonnesForcePerSquareMillimeter(double tonnesforcepersquaremillimeter)
+        public static Pressure FromTonnesForcePerSquareMillimeter(double value)
         {
-            return new Pressure(tonnesforcepersquaremillimeter, PressureUnit.TonneForcePerSquareMillimeter);
+            return new Pressure(value, PressureUnit.TonneForcePerSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Pressure"/> from <see cref="PressureUnit.Torr"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Pressure FromTorrs(double torrs)
+        public static Pressure FromTorrs(double value)
         {
-            return new Pressure(torrs, PressureUnit.Torr);
+            return new Pressure(value, PressureUnit.Torr);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
index e7db9ac5b0..8e1a30cec3 100644
--- a/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/PressureChangeRate.g.cs
@@ -364,162 +364,162 @@ public static string GetAbbreviation(PressureChangeRateUnit unit, IFormatProvide
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.AtmospherePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromAtmospheresPerSecond(double atmospherespersecond)
+        public static PressureChangeRate FromAtmospheresPerSecond(double value)
         {
-            return new PressureChangeRate(atmospherespersecond, PressureChangeRateUnit.AtmospherePerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.AtmospherePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.BarPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromBarsPerMinute(double barsperminute)
+        public static PressureChangeRate FromBarsPerMinute(double value)
         {
-            return new PressureChangeRate(barsperminute, PressureChangeRateUnit.BarPerMinute);
+            return new PressureChangeRate(value, PressureChangeRateUnit.BarPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.BarPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromBarsPerSecond(double barspersecond)
+        public static PressureChangeRate FromBarsPerSecond(double value)
         {
-            return new PressureChangeRate(barspersecond, PressureChangeRateUnit.BarPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.BarPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopascalPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopascalsPerMinute(double kilopascalsperminute)
+        public static PressureChangeRate FromKilopascalsPerMinute(double value)
         {
-            return new PressureChangeRate(kilopascalsperminute, PressureChangeRateUnit.KilopascalPerMinute);
+            return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopascalPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopascalsPerSecond(double kilopascalspersecond)
+        public static PressureChangeRate FromKilopascalsPerSecond(double value)
         {
-            return new PressureChangeRate(kilopascalspersecond, PressureChangeRateUnit.KilopascalPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.KilopascalPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(double kilopoundsforcepersquareinchperminute)
+        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerMinute(double value)
         {
-            return new PressureChangeRate(kilopoundsforcepersquareinchperminute, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
+            return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(double kilopoundsforcepersquareinchpersecond)
+        public static PressureChangeRate FromKilopoundsForcePerSquareInchPerSecond(double value)
         {
-            return new PressureChangeRate(kilopoundsforcepersquareinchpersecond, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.KilopoundForcePerSquareInchPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapascalPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapascalsPerMinute(double megapascalsperminute)
+        public static PressureChangeRate FromMegapascalsPerMinute(double value)
         {
-            return new PressureChangeRate(megapascalsperminute, PressureChangeRateUnit.MegapascalPerMinute);
+            return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapascalPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapascalsPerSecond(double megapascalspersecond)
+        public static PressureChangeRate FromMegapascalsPerSecond(double value)
         {
-            return new PressureChangeRate(megapascalspersecond, PressureChangeRateUnit.MegapascalPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.MegapascalPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(double megapoundsforcepersquareinchperminute)
+        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerMinute(double value)
         {
-            return new PressureChangeRate(megapoundsforcepersquareinchperminute, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
+            return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(double megapoundsforcepersquareinchpersecond)
+        public static PressureChangeRate FromMegapoundsForcePerSquareInchPerSecond(double value)
         {
-            return new PressureChangeRate(megapoundsforcepersquareinchpersecond, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.MegapoundForcePerSquareInchPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillibarPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMillibarsPerMinute(double millibarsperminute)
+        public static PressureChangeRate FromMillibarsPerMinute(double value)
         {
-            return new PressureChangeRate(millibarsperminute, PressureChangeRateUnit.MillibarPerMinute);
+            return new PressureChangeRate(value, PressureChangeRateUnit.MillibarPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillibarPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMillibarsPerSecond(double millibarspersecond)
+        public static PressureChangeRate FromMillibarsPerSecond(double value)
         {
-            return new PressureChangeRate(millibarspersecond, PressureChangeRateUnit.MillibarPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.MillibarPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.MillimeterOfMercuryPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromMillimetersOfMercuryPerSecond(double millimetersofmercurypersecond)
+        public static PressureChangeRate FromMillimetersOfMercuryPerSecond(double value)
         {
-            return new PressureChangeRate(millimetersofmercurypersecond, PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.MillimeterOfMercuryPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PascalPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPascalsPerMinute(double pascalsperminute)
+        public static PressureChangeRate FromPascalsPerMinute(double value)
         {
-            return new PressureChangeRate(pascalsperminute, PressureChangeRateUnit.PascalPerMinute);
+            return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PascalPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPascalsPerSecond(double pascalspersecond)
+        public static PressureChangeRate FromPascalsPerSecond(double value)
         {
-            return new PressureChangeRate(pascalspersecond, PressureChangeRateUnit.PascalPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.PascalPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double poundsforcepersquareinchperminute)
+        public static PressureChangeRate FromPoundsForcePerSquareInchPerMinute(double value)
         {
-            return new PressureChangeRate(poundsforcepersquareinchperminute, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
+            return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="PressureChangeRate"/> from <see cref="PressureChangeRateUnit.PoundForcePerSquareInchPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double poundsforcepersquareinchpersecond)
+        public static PressureChangeRate FromPoundsForcePerSquareInchPerSecond(double value)
         {
-            return new PressureChangeRate(poundsforcepersquareinchpersecond, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
+            return new PressureChangeRate(value, PressureChangeRateUnit.PoundForcePerSquareInchPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs b/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
index f611c99e5e..c59e62f5aa 100644
--- a/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RadiationExposure.g.cs
@@ -277,72 +277,72 @@ public static string GetAbbreviation(RadiationExposureUnit unit, IFormatProvider
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.CoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromCoulombsPerKilogram(double coulombsperkilogram)
+        public static RadiationExposure FromCoulombsPerKilogram(double value)
         {
-            return new RadiationExposure(coulombsperkilogram, RadiationExposureUnit.CoulombPerKilogram);
+            return new RadiationExposure(value, RadiationExposureUnit.CoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.MicrocoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromMicrocoulombsPerKilogram(double microcoulombsperkilogram)
+        public static RadiationExposure FromMicrocoulombsPerKilogram(double value)
         {
-            return new RadiationExposure(microcoulombsperkilogram, RadiationExposureUnit.MicrocoulombPerKilogram);
+            return new RadiationExposure(value, RadiationExposureUnit.MicrocoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Microroentgen"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromMicroroentgens(double microroentgens)
+        public static RadiationExposure FromMicroroentgens(double value)
         {
-            return new RadiationExposure(microroentgens, RadiationExposureUnit.Microroentgen);
+            return new RadiationExposure(value, RadiationExposureUnit.Microroentgen);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.MillicoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromMillicoulombsPerKilogram(double millicoulombsperkilogram)
+        public static RadiationExposure FromMillicoulombsPerKilogram(double value)
         {
-            return new RadiationExposure(millicoulombsperkilogram, RadiationExposureUnit.MillicoulombPerKilogram);
+            return new RadiationExposure(value, RadiationExposureUnit.MillicoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Milliroentgen"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromMilliroentgens(double milliroentgens)
+        public static RadiationExposure FromMilliroentgens(double value)
         {
-            return new RadiationExposure(milliroentgens, RadiationExposureUnit.Milliroentgen);
+            return new RadiationExposure(value, RadiationExposureUnit.Milliroentgen);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.NanocoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromNanocoulombsPerKilogram(double nanocoulombsperkilogram)
+        public static RadiationExposure FromNanocoulombsPerKilogram(double value)
         {
-            return new RadiationExposure(nanocoulombsperkilogram, RadiationExposureUnit.NanocoulombPerKilogram);
+            return new RadiationExposure(value, RadiationExposureUnit.NanocoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.PicocoulombPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromPicocoulombsPerKilogram(double picocoulombsperkilogram)
+        public static RadiationExposure FromPicocoulombsPerKilogram(double value)
         {
-            return new RadiationExposure(picocoulombsperkilogram, RadiationExposureUnit.PicocoulombPerKilogram);
+            return new RadiationExposure(value, RadiationExposureUnit.PicocoulombPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="RadiationExposure"/> from <see cref="RadiationExposureUnit.Roentgen"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RadiationExposure FromRoentgens(double roentgens)
+        public static RadiationExposure FromRoentgens(double value)
         {
-            return new RadiationExposure(roentgens, RadiationExposureUnit.Roentgen);
+            return new RadiationExposure(value, RadiationExposureUnit.Roentgen);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs b/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
index d44b97dd77..3352e42374 100644
--- a/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Radioactivity.g.cs
@@ -445,261 +445,261 @@ public static string GetAbbreviation(RadioactivityUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Becquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromBecquerels(double becquerels)
+        public static Radioactivity FromBecquerels(double value)
         {
-            return new Radioactivity(becquerels, RadioactivityUnit.Becquerel);
+            return new Radioactivity(value, RadioactivityUnit.Becquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Curie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromCuries(double curies)
+        public static Radioactivity FromCuries(double value)
         {
-            return new Radioactivity(curies, RadioactivityUnit.Curie);
+            return new Radioactivity(value, RadioactivityUnit.Curie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Exabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromExabecquerels(double exabecquerels)
+        public static Radioactivity FromExabecquerels(double value)
         {
-            return new Radioactivity(exabecquerels, RadioactivityUnit.Exabecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Exabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromGigabecquerels(double gigabecquerels)
+        public static Radioactivity FromGigabecquerels(double value)
         {
-            return new Radioactivity(gigabecquerels, RadioactivityUnit.Gigabecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Gigabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigacurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromGigacuries(double gigacuries)
+        public static Radioactivity FromGigacuries(double value)
         {
-            return new Radioactivity(gigacuries, RadioactivityUnit.Gigacurie);
+            return new Radioactivity(value, RadioactivityUnit.Gigacurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Gigarutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromGigarutherfords(double gigarutherfords)
+        public static Radioactivity FromGigarutherfords(double value)
         {
-            return new Radioactivity(gigarutherfords, RadioactivityUnit.Gigarutherford);
+            return new Radioactivity(value, RadioactivityUnit.Gigarutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilobecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromKilobecquerels(double kilobecquerels)
+        public static Radioactivity FromKilobecquerels(double value)
         {
-            return new Radioactivity(kilobecquerels, RadioactivityUnit.Kilobecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Kilobecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilocurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromKilocuries(double kilocuries)
+        public static Radioactivity FromKilocuries(double value)
         {
-            return new Radioactivity(kilocuries, RadioactivityUnit.Kilocurie);
+            return new Radioactivity(value, RadioactivityUnit.Kilocurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Kilorutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromKilorutherfords(double kilorutherfords)
+        public static Radioactivity FromKilorutherfords(double value)
         {
-            return new Radioactivity(kilorutherfords, RadioactivityUnit.Kilorutherford);
+            return new Radioactivity(value, RadioactivityUnit.Kilorutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMegabecquerels(double megabecquerels)
+        public static Radioactivity FromMegabecquerels(double value)
         {
-            return new Radioactivity(megabecquerels, RadioactivityUnit.Megabecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Megabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megacurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMegacuries(double megacuries)
+        public static Radioactivity FromMegacuries(double value)
         {
-            return new Radioactivity(megacuries, RadioactivityUnit.Megacurie);
+            return new Radioactivity(value, RadioactivityUnit.Megacurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Megarutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMegarutherfords(double megarutherfords)
+        public static Radioactivity FromMegarutherfords(double value)
         {
-            return new Radioactivity(megarutherfords, RadioactivityUnit.Megarutherford);
+            return new Radioactivity(value, RadioactivityUnit.Megarutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microbecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMicrobecquerels(double microbecquerels)
+        public static Radioactivity FromMicrobecquerels(double value)
         {
-            return new Radioactivity(microbecquerels, RadioactivityUnit.Microbecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Microbecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microcurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMicrocuries(double microcuries)
+        public static Radioactivity FromMicrocuries(double value)
         {
-            return new Radioactivity(microcuries, RadioactivityUnit.Microcurie);
+            return new Radioactivity(value, RadioactivityUnit.Microcurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Microrutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMicrorutherfords(double microrutherfords)
+        public static Radioactivity FromMicrorutherfords(double value)
         {
-            return new Radioactivity(microrutherfords, RadioactivityUnit.Microrutherford);
+            return new Radioactivity(value, RadioactivityUnit.Microrutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millibecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMillibecquerels(double millibecquerels)
+        public static Radioactivity FromMillibecquerels(double value)
         {
-            return new Radioactivity(millibecquerels, RadioactivityUnit.Millibecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Millibecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millicurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMillicuries(double millicuries)
+        public static Radioactivity FromMillicuries(double value)
         {
-            return new Radioactivity(millicuries, RadioactivityUnit.Millicurie);
+            return new Radioactivity(value, RadioactivityUnit.Millicurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Millirutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromMillirutherfords(double millirutherfords)
+        public static Radioactivity FromMillirutherfords(double value)
         {
-            return new Radioactivity(millirutherfords, RadioactivityUnit.Millirutherford);
+            return new Radioactivity(value, RadioactivityUnit.Millirutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanobecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromNanobecquerels(double nanobecquerels)
+        public static Radioactivity FromNanobecquerels(double value)
         {
-            return new Radioactivity(nanobecquerels, RadioactivityUnit.Nanobecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Nanobecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanocurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromNanocuries(double nanocuries)
+        public static Radioactivity FromNanocuries(double value)
         {
-            return new Radioactivity(nanocuries, RadioactivityUnit.Nanocurie);
+            return new Radioactivity(value, RadioactivityUnit.Nanocurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Nanorutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromNanorutherfords(double nanorutherfords)
+        public static Radioactivity FromNanorutherfords(double value)
         {
-            return new Radioactivity(nanorutherfords, RadioactivityUnit.Nanorutherford);
+            return new Radioactivity(value, RadioactivityUnit.Nanorutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Petabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromPetabecquerels(double petabecquerels)
+        public static Radioactivity FromPetabecquerels(double value)
         {
-            return new Radioactivity(petabecquerels, RadioactivityUnit.Petabecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Petabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picobecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromPicobecquerels(double picobecquerels)
+        public static Radioactivity FromPicobecquerels(double value)
         {
-            return new Radioactivity(picobecquerels, RadioactivityUnit.Picobecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Picobecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picocurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromPicocuries(double picocuries)
+        public static Radioactivity FromPicocuries(double value)
         {
-            return new Radioactivity(picocuries, RadioactivityUnit.Picocurie);
+            return new Radioactivity(value, RadioactivityUnit.Picocurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Picorutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromPicorutherfords(double picorutherfords)
+        public static Radioactivity FromPicorutherfords(double value)
         {
-            return new Radioactivity(picorutherfords, RadioactivityUnit.Picorutherford);
+            return new Radioactivity(value, RadioactivityUnit.Picorutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Rutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromRutherfords(double rutherfords)
+        public static Radioactivity FromRutherfords(double value)
         {
-            return new Radioactivity(rutherfords, RadioactivityUnit.Rutherford);
+            return new Radioactivity(value, RadioactivityUnit.Rutherford);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Terabecquerel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromTerabecquerels(double terabecquerels)
+        public static Radioactivity FromTerabecquerels(double value)
         {
-            return new Radioactivity(terabecquerels, RadioactivityUnit.Terabecquerel);
+            return new Radioactivity(value, RadioactivityUnit.Terabecquerel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Teracurie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromTeracuries(double teracuries)
+        public static Radioactivity FromTeracuries(double value)
         {
-            return new Radioactivity(teracuries, RadioactivityUnit.Teracurie);
+            return new Radioactivity(value, RadioactivityUnit.Teracurie);
         }
 
         /// <summary>
         ///     Creates a <see cref="Radioactivity"/> from <see cref="RadioactivityUnit.Terarutherford"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Radioactivity FromTerarutherfords(double terarutherfords)
+        public static Radioactivity FromTerarutherfords(double value)
         {
-            return new Radioactivity(terarutherfords, RadioactivityUnit.Terarutherford);
+            return new Radioactivity(value, RadioactivityUnit.Terarutherford);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
index 9ddb15bc47..1fb6bbbbcf 100644
--- a/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Ratio.g.cs
@@ -261,54 +261,54 @@ public static string GetAbbreviation(RatioUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.DecimalFraction"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromDecimalFractions(double decimalfractions)
+        public static Ratio FromDecimalFractions(double value)
         {
-            return new Ratio(decimalfractions, RatioUnit.DecimalFraction);
+            return new Ratio(value, RatioUnit.DecimalFraction);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerBillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerBillion(double partsperbillion)
+        public static Ratio FromPartsPerBillion(double value)
         {
-            return new Ratio(partsperbillion, RatioUnit.PartPerBillion);
+            return new Ratio(value, RatioUnit.PartPerBillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerMillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerMillion(double partspermillion)
+        public static Ratio FromPartsPerMillion(double value)
         {
-            return new Ratio(partspermillion, RatioUnit.PartPerMillion);
+            return new Ratio(value, RatioUnit.PartPerMillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerThousand"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerThousand(double partsperthousand)
+        public static Ratio FromPartsPerThousand(double value)
         {
-            return new Ratio(partsperthousand, RatioUnit.PartPerThousand);
+            return new Ratio(value, RatioUnit.PartPerThousand);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.PartPerTrillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPartsPerTrillion(double partspertrillion)
+        public static Ratio FromPartsPerTrillion(double value)
         {
-            return new Ratio(partspertrillion, RatioUnit.PartPerTrillion);
+            return new Ratio(value, RatioUnit.PartPerTrillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="Ratio"/> from <see cref="RatioUnit.Percent"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Ratio FromPercent(double percent)
+        public static Ratio FromPercent(double value)
         {
-            return new Ratio(percent, RatioUnit.Percent);
+            return new Ratio(value, RatioUnit.Percent);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
index 913a13decd..260c07aaa3 100644
--- a/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RatioChangeRate.g.cs
@@ -229,18 +229,18 @@ public static string GetAbbreviation(RatioChangeRateUnit unit, IFormatProvider?
         ///     Creates a <see cref="RatioChangeRate"/> from <see cref="RatioChangeRateUnit.DecimalFractionPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RatioChangeRate FromDecimalFractionsPerSecond(double decimalfractionspersecond)
+        public static RatioChangeRate FromDecimalFractionsPerSecond(double value)
         {
-            return new RatioChangeRate(decimalfractionspersecond, RatioChangeRateUnit.DecimalFractionPerSecond);
+            return new RatioChangeRate(value, RatioChangeRateUnit.DecimalFractionPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RatioChangeRate"/> from <see cref="RatioChangeRateUnit.PercentPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RatioChangeRate FromPercentsPerSecond(double percentspersecond)
+        public static RatioChangeRate FromPercentsPerSecond(double value)
         {
-            return new RatioChangeRate(percentspersecond, RatioChangeRateUnit.PercentPerSecond);
+            return new RatioChangeRate(value, RatioChangeRateUnit.PercentPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
index 4da15c9eb7..4bd7c1f568 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReactiveEnergy.g.cs
@@ -237,27 +237,27 @@ public static string GetAbbreviation(ReactiveEnergyUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ReactiveEnergy"/> from <see cref="ReactiveEnergyUnit.KilovoltampereReactiveHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromKilovoltampereReactiveHours(double kilovoltamperereactivehours)
+        public static ReactiveEnergy FromKilovoltampereReactiveHours(double value)
         {
-            return new ReactiveEnergy(kilovoltamperereactivehours, ReactiveEnergyUnit.KilovoltampereReactiveHour);
+            return new ReactiveEnergy(value, ReactiveEnergyUnit.KilovoltampereReactiveHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactiveEnergy"/> from <see cref="ReactiveEnergyUnit.MegavoltampereReactiveHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromMegavoltampereReactiveHours(double megavoltamperereactivehours)
+        public static ReactiveEnergy FromMegavoltampereReactiveHours(double value)
         {
-            return new ReactiveEnergy(megavoltamperereactivehours, ReactiveEnergyUnit.MegavoltampereReactiveHour);
+            return new ReactiveEnergy(value, ReactiveEnergyUnit.MegavoltampereReactiveHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactiveEnergy"/> from <see cref="ReactiveEnergyUnit.VoltampereReactiveHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactiveEnergy FromVoltampereReactiveHours(double voltamperereactivehours)
+        public static ReactiveEnergy FromVoltampereReactiveHours(double value)
         {
-            return new ReactiveEnergy(voltamperereactivehours, ReactiveEnergyUnit.VoltampereReactiveHour);
+            return new ReactiveEnergy(value, ReactiveEnergyUnit.VoltampereReactiveHour);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
index f25c534690..d17a467580 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReactivePower.g.cs
@@ -245,36 +245,36 @@ public static string GetAbbreviation(ReactivePowerUnit unit, IFormatProvider? pr
         ///     Creates a <see cref="ReactivePower"/> from <see cref="ReactivePowerUnit.GigavoltampereReactive"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromGigavoltamperesReactive(double gigavoltamperesreactive)
+        public static ReactivePower FromGigavoltamperesReactive(double value)
         {
-            return new ReactivePower(gigavoltamperesreactive, ReactivePowerUnit.GigavoltampereReactive);
+            return new ReactivePower(value, ReactivePowerUnit.GigavoltampereReactive);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactivePower"/> from <see cref="ReactivePowerUnit.KilovoltampereReactive"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromKilovoltamperesReactive(double kilovoltamperesreactive)
+        public static ReactivePower FromKilovoltamperesReactive(double value)
         {
-            return new ReactivePower(kilovoltamperesreactive, ReactivePowerUnit.KilovoltampereReactive);
+            return new ReactivePower(value, ReactivePowerUnit.KilovoltampereReactive);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactivePower"/> from <see cref="ReactivePowerUnit.MegavoltampereReactive"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromMegavoltamperesReactive(double megavoltamperesreactive)
+        public static ReactivePower FromMegavoltamperesReactive(double value)
         {
-            return new ReactivePower(megavoltamperesreactive, ReactivePowerUnit.MegavoltampereReactive);
+            return new ReactivePower(value, ReactivePowerUnit.MegavoltampereReactive);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReactivePower"/> from <see cref="ReactivePowerUnit.VoltampereReactive"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReactivePower FromVoltamperesReactive(double voltamperesreactive)
+        public static ReactivePower FromVoltamperesReactive(double value)
         {
-            return new ReactivePower(voltamperesreactive, ReactivePowerUnit.VoltampereReactive);
+            return new ReactivePower(value, ReactivePowerUnit.VoltampereReactive);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
index 4ffad89940..f199c851f3 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalArea.g.cs
@@ -312,99 +312,99 @@ public static string GetAbbreviation(ReciprocalAreaUnit unit, IFormatProvider? p
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareCentimeters(double inversesquarecentimeters)
+        public static ReciprocalArea FromInverseSquareCentimeters(double value)
         {
-            return new ReciprocalArea(inversesquarecentimeters, ReciprocalAreaUnit.InverseSquareCentimeter);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareDecimeters(double inversesquaredecimeters)
+        public static ReciprocalArea FromInverseSquareDecimeters(double value)
         {
-            return new ReciprocalArea(inversesquaredecimeters, ReciprocalAreaUnit.InverseSquareDecimeter);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareFeet(double inversesquarefeet)
+        public static ReciprocalArea FromInverseSquareFeet(double value)
         {
-            return new ReciprocalArea(inversesquarefeet, ReciprocalAreaUnit.InverseSquareFoot);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareInches(double inversesquareinches)
+        public static ReciprocalArea FromInverseSquareInches(double value)
         {
-            return new ReciprocalArea(inversesquareinches, ReciprocalAreaUnit.InverseSquareInch);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareKilometers(double inversesquarekilometers)
+        public static ReciprocalArea FromInverseSquareKilometers(double value)
         {
-            return new ReciprocalArea(inversesquarekilometers, ReciprocalAreaUnit.InverseSquareKilometer);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareMeters(double inversesquaremeters)
+        public static ReciprocalArea FromInverseSquareMeters(double value)
         {
-            return new ReciprocalArea(inversesquaremeters, ReciprocalAreaUnit.InverseSquareMeter);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMicrometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareMicrometers(double inversesquaremicrometers)
+        public static ReciprocalArea FromInverseSquareMicrometers(double value)
         {
-            return new ReciprocalArea(inversesquaremicrometers, ReciprocalAreaUnit.InverseSquareMicrometer);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMicrometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareMiles(double inversesquaremiles)
+        public static ReciprocalArea FromInverseSquareMiles(double value)
         {
-            return new ReciprocalArea(inversesquaremiles, ReciprocalAreaUnit.InverseSquareMile);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareMillimeters(double inversesquaremillimeters)
+        public static ReciprocalArea FromInverseSquareMillimeters(double value)
         {
-            return new ReciprocalArea(inversesquaremillimeters, ReciprocalAreaUnit.InverseSquareMillimeter);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseSquareYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseSquareYards(double inversesquareyards)
+        public static ReciprocalArea FromInverseSquareYards(double value)
         {
-            return new ReciprocalArea(inversesquareyards, ReciprocalAreaUnit.InverseSquareYard);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseSquareYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalArea"/> from <see cref="ReciprocalAreaUnit.InverseUsSurveySquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalArea FromInverseUsSurveySquareFeet(double inverseussurveysquarefeet)
+        public static ReciprocalArea FromInverseUsSurveySquareFeet(double value)
         {
-            return new ReciprocalArea(inverseussurveysquarefeet, ReciprocalAreaUnit.InverseUsSurveySquareFoot);
+            return new ReciprocalArea(value, ReciprocalAreaUnit.InverseUsSurveySquareFoot);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
index e980cebee2..cd0c508f5c 100644
--- a/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ReciprocalLength.g.cs
@@ -305,90 +305,90 @@ public static string GetAbbreviation(ReciprocalLengthUnit unit, IFormatProvider?
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseCentimeters(double inversecentimeters)
+        public static ReciprocalLength FromInverseCentimeters(double value)
         {
-            return new ReciprocalLength(inversecentimeters, ReciprocalLengthUnit.InverseCentimeter);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseFeet(double inversefeet)
+        public static ReciprocalLength FromInverseFeet(double value)
         {
-            return new ReciprocalLength(inversefeet, ReciprocalLengthUnit.InverseFoot);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseInches(double inverseinches)
+        public static ReciprocalLength FromInverseInches(double value)
         {
-            return new ReciprocalLength(inverseinches, ReciprocalLengthUnit.InverseInch);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMeters(double inversemeters)
+        public static ReciprocalLength FromInverseMeters(double value)
         {
-            return new ReciprocalLength(inversemeters, ReciprocalLengthUnit.InverseMeter);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMicroinch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMicroinches(double inversemicroinches)
+        public static ReciprocalLength FromInverseMicroinches(double value)
         {
-            return new ReciprocalLength(inversemicroinches, ReciprocalLengthUnit.InverseMicroinch);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMicroinch);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMil"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMils(double inversemils)
+        public static ReciprocalLength FromInverseMils(double value)
         {
-            return new ReciprocalLength(inversemils, ReciprocalLengthUnit.InverseMil);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMil);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMiles(double inversemiles)
+        public static ReciprocalLength FromInverseMiles(double value)
         {
-            return new ReciprocalLength(inversemiles, ReciprocalLengthUnit.InverseMile);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseMillimeters(double inversemillimeters)
+        public static ReciprocalLength FromInverseMillimeters(double value)
         {
-            return new ReciprocalLength(inversemillimeters, ReciprocalLengthUnit.InverseMillimeter);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseUsSurveyFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseUsSurveyFeet(double inverseussurveyfeet)
+        public static ReciprocalLength FromInverseUsSurveyFeet(double value)
         {
-            return new ReciprocalLength(inverseussurveyfeet, ReciprocalLengthUnit.InverseUsSurveyFoot);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseUsSurveyFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="ReciprocalLength"/> from <see cref="ReciprocalLengthUnit.InverseYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ReciprocalLength FromInverseYards(double inverseyards)
+        public static ReciprocalLength FromInverseYards(double value)
         {
-            return new ReciprocalLength(inverseyards, ReciprocalLengthUnit.InverseYard);
+            return new ReciprocalLength(value, ReciprocalLengthUnit.InverseYard);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
index c66c66a8ea..fed47ea88e 100644
--- a/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RelativeHumidity.g.cs
@@ -221,9 +221,9 @@ public static string GetAbbreviation(RelativeHumidityUnit unit, IFormatProvider?
         ///     Creates a <see cref="RelativeHumidity"/> from <see cref="RelativeHumidityUnit.Percent"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RelativeHumidity FromPercent(double percent)
+        public static RelativeHumidity FromPercent(double value)
         {
-            return new RelativeHumidity(percent, RelativeHumidityUnit.Percent);
+            return new RelativeHumidity(value, RelativeHumidityUnit.Percent);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
index 2131f06cbd..0e8da007b2 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalAcceleration.g.cs
@@ -245,36 +245,36 @@ public static string GetAbbreviation(RotationalAccelerationUnit unit, IFormatPro
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.DegreePerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromDegreesPerSecondSquared(double degreespersecondsquared)
+        public static RotationalAcceleration FromDegreesPerSecondSquared(double value)
         {
-            return new RotationalAcceleration(degreespersecondsquared, RotationalAccelerationUnit.DegreePerSecondSquared);
+            return new RotationalAcceleration(value, RotationalAccelerationUnit.DegreePerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RadianPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRadiansPerSecondSquared(double radianspersecondsquared)
+        public static RotationalAcceleration FromRadiansPerSecondSquared(double value)
         {
-            return new RotationalAcceleration(radianspersecondsquared, RotationalAccelerationUnit.RadianPerSecondSquared);
+            return new RotationalAcceleration(value, RotationalAccelerationUnit.RadianPerSecondSquared);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RevolutionPerMinutePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(double revolutionsperminutepersecond)
+        public static RotationalAcceleration FromRevolutionsPerMinutePerSecond(double value)
         {
-            return new RotationalAcceleration(revolutionsperminutepersecond, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
+            return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerMinutePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalAcceleration"/> from <see cref="RotationalAccelerationUnit.RevolutionPerSecondSquared"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalAcceleration FromRevolutionsPerSecondSquared(double revolutionspersecondsquared)
+        public static RotationalAcceleration FromRevolutionsPerSecondSquared(double value)
         {
-            return new RotationalAcceleration(revolutionspersecondsquared, RotationalAccelerationUnit.RevolutionPerSecondSquared);
+            return new RotationalAcceleration(value, RotationalAccelerationUnit.RevolutionPerSecondSquared);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
index 3a0bb6bc99..34aba5fcd1 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalSpeed.g.cs
@@ -324,117 +324,117 @@ public static string GetAbbreviation(RotationalSpeedUnit unit, IFormatProvider?
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.CentiradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromCentiradiansPerSecond(double centiradianspersecond)
+        public static RotationalSpeed FromCentiradiansPerSecond(double value)
         {
-            return new RotationalSpeed(centiradianspersecond, RotationalSpeedUnit.CentiradianPerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.CentiradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DeciradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDeciradiansPerSecond(double deciradianspersecond)
+        public static RotationalSpeed FromDeciradiansPerSecond(double value)
         {
-            return new RotationalSpeed(deciradianspersecond, RotationalSpeedUnit.DeciradianPerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.DeciradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DegreePerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDegreesPerMinute(double degreesperminute)
+        public static RotationalSpeed FromDegreesPerMinute(double value)
         {
-            return new RotationalSpeed(degreesperminute, RotationalSpeedUnit.DegreePerMinute);
+            return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.DegreePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromDegreesPerSecond(double degreespersecond)
+        public static RotationalSpeed FromDegreesPerSecond(double value)
         {
-            return new RotationalSpeed(degreespersecond, RotationalSpeedUnit.DegreePerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.DegreePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MicrodegreePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMicrodegreesPerSecond(double microdegreespersecond)
+        public static RotationalSpeed FromMicrodegreesPerSecond(double value)
         {
-            return new RotationalSpeed(microdegreespersecond, RotationalSpeedUnit.MicrodegreePerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.MicrodegreePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MicroradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMicroradiansPerSecond(double microradianspersecond)
+        public static RotationalSpeed FromMicroradiansPerSecond(double value)
         {
-            return new RotationalSpeed(microradianspersecond, RotationalSpeedUnit.MicroradianPerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.MicroradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MillidegreePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMillidegreesPerSecond(double millidegreespersecond)
+        public static RotationalSpeed FromMillidegreesPerSecond(double value)
         {
-            return new RotationalSpeed(millidegreespersecond, RotationalSpeedUnit.MillidegreePerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.MillidegreePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.MilliradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromMilliradiansPerSecond(double milliradianspersecond)
+        public static RotationalSpeed FromMilliradiansPerSecond(double value)
         {
-            return new RotationalSpeed(milliradianspersecond, RotationalSpeedUnit.MilliradianPerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.MilliradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.NanodegreePerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromNanodegreesPerSecond(double nanodegreespersecond)
+        public static RotationalSpeed FromNanodegreesPerSecond(double value)
         {
-            return new RotationalSpeed(nanodegreespersecond, RotationalSpeedUnit.NanodegreePerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.NanodegreePerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.NanoradianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromNanoradiansPerSecond(double nanoradianspersecond)
+        public static RotationalSpeed FromNanoradiansPerSecond(double value)
         {
-            return new RotationalSpeed(nanoradianspersecond, RotationalSpeedUnit.NanoradianPerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.NanoradianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RadianPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRadiansPerSecond(double radianspersecond)
+        public static RotationalSpeed FromRadiansPerSecond(double value)
         {
-            return new RotationalSpeed(radianspersecond, RotationalSpeedUnit.RadianPerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.RadianPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RevolutionPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRevolutionsPerMinute(double revolutionsperminute)
+        public static RotationalSpeed FromRevolutionsPerMinute(double value)
         {
-            return new RotationalSpeed(revolutionsperminute, RotationalSpeedUnit.RevolutionPerMinute);
+            return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalSpeed"/> from <see cref="RotationalSpeedUnit.RevolutionPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalSpeed FromRevolutionsPerSecond(double revolutionspersecond)
+        public static RotationalSpeed FromRevolutionsPerSecond(double value)
         {
-            return new RotationalSpeed(revolutionspersecond, RotationalSpeedUnit.RevolutionPerSecond);
+            return new RotationalSpeed(value, RotationalSpeedUnit.RevolutionPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
index e6ed3b465c..1cff4a3834 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -485,297 +485,297 @@ public static string GetAbbreviation(RotationalStiffnessUnit unit, IFormatProvid
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMetersPerDegree(double centinewtonmetersperdegree)
+        public static RotationalStiffness FromCentinewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(centinewtonmetersperdegree, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMillimetersPerDegree(double centinewtonmillimetersperdegree)
+        public static RotationalStiffness FromCentinewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(centinewtonmillimetersperdegree, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.CentinewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromCentinewtonMillimetersPerRadian(double centinewtonmillimetersperradian)
+        public static RotationalStiffness FromCentinewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(centinewtonmillimetersperradian, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.CentinewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMetersPerDegree(double decanewtonmetersperdegree)
+        public static RotationalStiffness FromDecanewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(decanewtonmetersperdegree, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMillimetersPerDegree(double decanewtonmillimetersperdegree)
+        public static RotationalStiffness FromDecanewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(decanewtonmillimetersperdegree, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecanewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecanewtonMillimetersPerRadian(double decanewtonmillimetersperradian)
+        public static RotationalStiffness FromDecanewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(decanewtonmillimetersperradian, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.DecanewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMetersPerDegree(double decinewtonmetersperdegree)
+        public static RotationalStiffness FromDecinewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(decinewtonmetersperdegree, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMillimetersPerDegree(double decinewtonmillimetersperdegree)
+        public static RotationalStiffness FromDecinewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(decinewtonmillimetersperdegree, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.DecinewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromDecinewtonMillimetersPerRadian(double decinewtonmillimetersperradian)
+        public static RotationalStiffness FromDecinewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(decinewtonmillimetersperradian, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.DecinewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMetersPerDegree(double kilonewtonmetersperdegree)
+        public static RotationalStiffness FromKilonewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(kilonewtonmetersperdegree, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMetersPerRadian(double kilonewtonmetersperradian)
+        public static RotationalStiffness FromKilonewtonMetersPerRadian(double value)
         {
-            return new RotationalStiffness(kilonewtonmetersperradian, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMillimetersPerDegree(double kilonewtonmillimetersperdegree)
+        public static RotationalStiffness FromKilonewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(kilonewtonmillimetersperdegree, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilonewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilonewtonMillimetersPerRadian(double kilonewtonmillimetersperradian)
+        public static RotationalStiffness FromKilonewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(kilonewtonmillimetersperradian, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.KilopoundForceFootPerDegrees"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double kilopoundforcefeetperdegrees)
+        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double value)
         {
-            return new RotationalStiffness(kilopoundforcefeetperdegrees, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMetersPerDegree(double meganewtonmetersperdegree)
+        public static RotationalStiffness FromMeganewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(meganewtonmetersperdegree, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMetersPerRadian(double meganewtonmetersperradian)
+        public static RotationalStiffness FromMeganewtonMetersPerRadian(double value)
         {
-            return new RotationalStiffness(meganewtonmetersperradian, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMillimetersPerDegree(double meganewtonmillimetersperdegree)
+        public static RotationalStiffness FromMeganewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(meganewtonmillimetersperdegree, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MeganewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMeganewtonMillimetersPerRadian(double meganewtonmillimetersperradian)
+        public static RotationalStiffness FromMeganewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(meganewtonmillimetersperradian, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MeganewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMetersPerDegree(double micronewtonmetersperdegree)
+        public static RotationalStiffness FromMicronewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(micronewtonmetersperdegree, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMillimetersPerDegree(double micronewtonmillimetersperdegree)
+        public static RotationalStiffness FromMicronewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(micronewtonmillimetersperdegree, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MicronewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMicronewtonMillimetersPerRadian(double micronewtonmillimetersperradian)
+        public static RotationalStiffness FromMicronewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(micronewtonmillimetersperradian, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MicronewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMetersPerDegree(double millinewtonmetersperdegree)
+        public static RotationalStiffness FromMillinewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(millinewtonmetersperdegree, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMillimetersPerDegree(double millinewtonmillimetersperdegree)
+        public static RotationalStiffness FromMillinewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(millinewtonmillimetersperdegree, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.MillinewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromMillinewtonMillimetersPerRadian(double millinewtonmillimetersperradian)
+        public static RotationalStiffness FromMillinewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(millinewtonmillimetersperradian, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.MillinewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMetersPerDegree(double nanonewtonmetersperdegree)
+        public static RotationalStiffness FromNanonewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(nanonewtonmetersperdegree, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMillimetersPerDegree(double nanonewtonmillimetersperdegree)
+        public static RotationalStiffness FromNanonewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(nanonewtonmillimetersperdegree, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NanonewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNanonewtonMillimetersPerRadian(double nanonewtonmillimetersperradian)
+        public static RotationalStiffness FromNanonewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(nanonewtonmillimetersperradian, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.NanonewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMetersPerDegree(double newtonmetersperdegree)
+        public static RotationalStiffness FromNewtonMetersPerDegree(double value)
         {
-            return new RotationalStiffness(newtonmetersperdegree, RotationalStiffnessUnit.NewtonMeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMetersPerRadian(double newtonmetersperradian)
+        public static RotationalStiffness FromNewtonMetersPerRadian(double value)
         {
-            return new RotationalStiffness(newtonmetersperradian, RotationalStiffnessUnit.NewtonMeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMillimeterPerDegree"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMillimetersPerDegree(double newtonmillimetersperdegree)
+        public static RotationalStiffness FromNewtonMillimetersPerDegree(double value)
         {
-            return new RotationalStiffness(newtonmillimetersperdegree, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerDegree);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.NewtonMillimeterPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromNewtonMillimetersPerRadian(double newtonmillimetersperradian)
+        public static RotationalStiffness FromNewtonMillimetersPerRadian(double value)
         {
-            return new RotationalStiffness(newtonmillimetersperradian, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMillimeterPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.PoundForceFeetPerRadian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromPoundForceFeetPerRadian(double poundforcefeetperradian)
+        public static RotationalStiffness FromPoundForceFeetPerRadian(double value)
         {
-            return new RotationalStiffness(poundforcefeetperradian, RotationalStiffnessUnit.PoundForceFeetPerRadian);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFeetPerRadian);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffness"/> from <see cref="RotationalStiffnessUnit.PoundForceFootPerDegrees"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffness FromPoundForceFeetPerDegrees(double poundforcefeetperdegrees)
+        public static RotationalStiffness FromPoundForceFeetPerDegrees(double value)
         {
-            return new RotationalStiffness(poundforcefeetperdegrees, RotationalStiffnessUnit.PoundForceFootPerDegrees);
+            return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
index 0610388521..ca069a66c6 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffnessPerLength.g.cs
@@ -259,45 +259,45 @@ public static string GetAbbreviation(RotationalStiffnessPerLengthUnit unit, IFor
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter(double kilonewtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength FromKilonewtonMetersPerRadianPerMeter(double value)
         {
-            return new RotationalStiffnessPerLength(kilonewtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFeet(double kilopoundforcefeetperdegreesperfeet)
+        public static RotationalStiffnessPerLength FromKilopoundForceFeetPerDegreesPerFeet(double value)
         {
-            return new RotationalStiffnessPerLength(kilopoundforcefeetperdegreesperfeet, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
+            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.KilopoundForceFootPerDegreesPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter(double meganewtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength FromMeganewtonMetersPerRadianPerMeter(double value)
         {
-            return new RotationalStiffnessPerLength(meganewtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(double newtonmetersperradianpermeter)
+        public static RotationalStiffnessPerLength FromNewtonMetersPerRadianPerMeter(double value)
         {
-            return new RotationalStiffnessPerLength(newtonmetersperradianpermeter, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
+            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="RotationalStiffnessPerLength"/> from <see cref="RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(double poundforcefeetperdegreesperfeet)
+        public static RotationalStiffnessPerLength FromPoundForceFeetPerDegreesPerFeet(double value)
         {
-            return new RotationalStiffnessPerLength(poundforcefeetperdegreesperfeet, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
+            return new RotationalStiffnessPerLength(value, RotationalStiffnessPerLengthUnit.PoundForceFootPerDegreesPerFoot);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
index 0851f5db17..5687e7fa21 100644
--- a/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Scalar.g.cs
@@ -221,9 +221,9 @@ public static string GetAbbreviation(ScalarUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Scalar"/> from <see cref="ScalarUnit.Amount"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Scalar FromAmount(double amount)
+        public static Scalar FromAmount(double value)
         {
-            return new Scalar(amount, ScalarUnit.Amount);
+            return new Scalar(value, ScalarUnit.Amount);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
index d53fbdc6b3..f6d3019ff0 100644
--- a/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SolidAngle.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(SolidAngleUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="SolidAngle"/> from <see cref="SolidAngleUnit.Steradian"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SolidAngle FromSteradians(double steradians)
+        public static SolidAngle FromSteradians(double value)
         {
-            return new SolidAngle(steradians, SolidAngleUnit.Steradian);
+            return new SolidAngle(value, SolidAngleUnit.Steradian);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
index 2ef4ebbb14..adedb15a0c 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEnergy.g.cs
@@ -465,270 +465,270 @@ public static string GetAbbreviation(SpecificEnergyUnit unit, IFormatProvider? p
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.BtuPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromBtuPerPound(double btuperpound)
+        public static SpecificEnergy FromBtuPerPound(double value)
         {
-            return new SpecificEnergy(btuperpound, SpecificEnergyUnit.BtuPerPound);
+            return new SpecificEnergy(value, SpecificEnergyUnit.BtuPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.CaloriePerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromCaloriesPerGram(double caloriespergram)
+        public static SpecificEnergy FromCaloriesPerGram(double value)
         {
-            return new SpecificEnergy(caloriespergram, SpecificEnergyUnit.CaloriePerGram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.CaloriePerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerKilogram(double gigawattdaysperkilogram)
+        public static SpecificEnergy FromGigawattDaysPerKilogram(double value)
         {
-            return new SpecificEnergy(gigawattdaysperkilogram, SpecificEnergyUnit.GigawattDayPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerShortTon(double gigawattdayspershortton)
+        public static SpecificEnergy FromGigawattDaysPerShortTon(double value)
         {
-            return new SpecificEnergy(gigawattdayspershortton, SpecificEnergyUnit.GigawattDayPerShortTon);
+            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattDaysPerTonne(double gigawattdayspertonne)
+        public static SpecificEnergy FromGigawattDaysPerTonne(double value)
         {
-            return new SpecificEnergy(gigawattdayspertonne, SpecificEnergyUnit.GigawattDayPerTonne);
+            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattHourPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattHoursPerKilogram(double gigawatthoursperkilogram)
+        public static SpecificEnergy FromGigawattHoursPerKilogram(double value)
         {
-            return new SpecificEnergy(gigawatthoursperkilogram, SpecificEnergyUnit.GigawattHourPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.GigawattHourPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromGigawattHoursPerPound(double gigawatthoursperpound)
+        public static SpecificEnergy FromGigawattHoursPerPound(double value)
         {
-            return new SpecificEnergy(gigawatthoursperpound, SpecificEnergyUnit.GigawattHourPerPound);
+            return new SpecificEnergy(value, SpecificEnergyUnit.GigawattHourPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.JoulePerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromJoulesPerKilogram(double joulesperkilogram)
+        public static SpecificEnergy FromJoulesPerKilogram(double value)
         {
-            return new SpecificEnergy(joulesperkilogram, SpecificEnergyUnit.JoulePerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.JoulePerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilocaloriePerGram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilocaloriesPerGram(double kilocaloriespergram)
+        public static SpecificEnergy FromKilocaloriesPerGram(double value)
         {
-            return new SpecificEnergy(kilocaloriespergram, SpecificEnergyUnit.KilocaloriePerGram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.KilocaloriePerGram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilojoulePerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilojoulesPerKilogram(double kilojoulesperkilogram)
+        public static SpecificEnergy FromKilojoulesPerKilogram(double value)
         {
-            return new SpecificEnergy(kilojoulesperkilogram, SpecificEnergyUnit.KilojoulePerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.KilojoulePerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerKilogram(double kilowattdaysperkilogram)
+        public static SpecificEnergy FromKilowattDaysPerKilogram(double value)
         {
-            return new SpecificEnergy(kilowattdaysperkilogram, SpecificEnergyUnit.KilowattDayPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerShortTon(double kilowattdayspershortton)
+        public static SpecificEnergy FromKilowattDaysPerShortTon(double value)
         {
-            return new SpecificEnergy(kilowattdayspershortton, SpecificEnergyUnit.KilowattDayPerShortTon);
+            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattDaysPerTonne(double kilowattdayspertonne)
+        public static SpecificEnergy FromKilowattDaysPerTonne(double value)
         {
-            return new SpecificEnergy(kilowattdayspertonne, SpecificEnergyUnit.KilowattDayPerTonne);
+            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattHourPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattHoursPerKilogram(double kilowatthoursperkilogram)
+        public static SpecificEnergy FromKilowattHoursPerKilogram(double value)
         {
-            return new SpecificEnergy(kilowatthoursperkilogram, SpecificEnergyUnit.KilowattHourPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.KilowattHourPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromKilowattHoursPerPound(double kilowatthoursperpound)
+        public static SpecificEnergy FromKilowattHoursPerPound(double value)
         {
-            return new SpecificEnergy(kilowatthoursperpound, SpecificEnergyUnit.KilowattHourPerPound);
+            return new SpecificEnergy(value, SpecificEnergyUnit.KilowattHourPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegajoulePerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegajoulesPerKilogram(double megajoulesperkilogram)
+        public static SpecificEnergy FromMegajoulesPerKilogram(double value)
         {
-            return new SpecificEnergy(megajoulesperkilogram, SpecificEnergyUnit.MegajoulePerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.MegajoulePerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegaJoulePerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegaJoulesPerTonne(double megajoulespertonne)
+        public static SpecificEnergy FromMegaJoulesPerTonne(double value)
         {
-            return new SpecificEnergy(megajoulespertonne, SpecificEnergyUnit.MegaJoulePerTonne);
+            return new SpecificEnergy(value, SpecificEnergyUnit.MegaJoulePerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerKilogram(double megawattdaysperkilogram)
+        public static SpecificEnergy FromMegawattDaysPerKilogram(double value)
         {
-            return new SpecificEnergy(megawattdaysperkilogram, SpecificEnergyUnit.MegawattDayPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerShortTon(double megawattdayspershortton)
+        public static SpecificEnergy FromMegawattDaysPerShortTon(double value)
         {
-            return new SpecificEnergy(megawattdayspershortton, SpecificEnergyUnit.MegawattDayPerShortTon);
+            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattDaysPerTonne(double megawattdayspertonne)
+        public static SpecificEnergy FromMegawattDaysPerTonne(double value)
         {
-            return new SpecificEnergy(megawattdayspertonne, SpecificEnergyUnit.MegawattDayPerTonne);
+            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattHourPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattHoursPerKilogram(double megawatthoursperkilogram)
+        public static SpecificEnergy FromMegawattHoursPerKilogram(double value)
         {
-            return new SpecificEnergy(megawatthoursperkilogram, SpecificEnergyUnit.MegawattHourPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.MegawattHourPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromMegawattHoursPerPound(double megawatthoursperpound)
+        public static SpecificEnergy FromMegawattHoursPerPound(double value)
         {
-            return new SpecificEnergy(megawatthoursperpound, SpecificEnergyUnit.MegawattHourPerPound);
+            return new SpecificEnergy(value, SpecificEnergyUnit.MegawattHourPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerKilogram(double terawattdaysperkilogram)
+        public static SpecificEnergy FromTerawattDaysPerKilogram(double value)
         {
-            return new SpecificEnergy(terawattdaysperkilogram, SpecificEnergyUnit.TerawattDayPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerShortTon(double terawattdayspershortton)
+        public static SpecificEnergy FromTerawattDaysPerShortTon(double value)
         {
-            return new SpecificEnergy(terawattdayspershortton, SpecificEnergyUnit.TerawattDayPerShortTon);
+            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.TerawattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromTerawattDaysPerTonne(double terawattdayspertonne)
+        public static SpecificEnergy FromTerawattDaysPerTonne(double value)
         {
-            return new SpecificEnergy(terawattdayspertonne, SpecificEnergyUnit.TerawattDayPerTonne);
+            return new SpecificEnergy(value, SpecificEnergyUnit.TerawattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerKilogram(double wattdaysperkilogram)
+        public static SpecificEnergy FromWattDaysPerKilogram(double value)
         {
-            return new SpecificEnergy(wattdaysperkilogram, SpecificEnergyUnit.WattDayPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerShortTon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerShortTon(double wattdayspershortton)
+        public static SpecificEnergy FromWattDaysPerShortTon(double value)
         {
-            return new SpecificEnergy(wattdayspershortton, SpecificEnergyUnit.WattDayPerShortTon);
+            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerShortTon);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattDayPerTonne"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattDaysPerTonne(double wattdayspertonne)
+        public static SpecificEnergy FromWattDaysPerTonne(double value)
         {
-            return new SpecificEnergy(wattdayspertonne, SpecificEnergyUnit.WattDayPerTonne);
+            return new SpecificEnergy(value, SpecificEnergyUnit.WattDayPerTonne);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattHourPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattHoursPerKilogram(double watthoursperkilogram)
+        public static SpecificEnergy FromWattHoursPerKilogram(double value)
         {
-            return new SpecificEnergy(watthoursperkilogram, SpecificEnergyUnit.WattHourPerKilogram);
+            return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEnergy"/> from <see cref="SpecificEnergyUnit.WattHourPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEnergy FromWattHoursPerPound(double watthoursperpound)
+        public static SpecificEnergy FromWattHoursPerPound(double value)
         {
-            return new SpecificEnergy(watthoursperpound, SpecificEnergyUnit.WattHourPerPound);
+            return new SpecificEnergy(value, SpecificEnergyUnit.WattHourPerPound);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
index 7111f179f8..a992921ae0 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificEntropy.g.cs
@@ -292,81 +292,81 @@ public static string GetAbbreviation(SpecificEntropyUnit unit, IFormatProvider?
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.BtuPerPoundFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromBtusPerPoundFahrenheit(double btusperpoundfahrenheit)
+        public static SpecificEntropy FromBtusPerPoundFahrenheit(double value)
         {
-            return new SpecificEntropy(btusperpoundfahrenheit, SpecificEntropyUnit.BtuPerPoundFahrenheit);
+            return new SpecificEntropy(value, SpecificEntropyUnit.BtuPerPoundFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.CaloriePerGramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromCaloriesPerGramKelvin(double caloriespergramkelvin)
+        public static SpecificEntropy FromCaloriesPerGramKelvin(double value)
         {
-            return new SpecificEntropy(caloriespergramkelvin, SpecificEntropyUnit.CaloriePerGramKelvin);
+            return new SpecificEntropy(value, SpecificEntropyUnit.CaloriePerGramKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.JoulePerKilogramDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(double joulesperkilogramdegreecelsius)
+        public static SpecificEntropy FromJoulesPerKilogramDegreeCelsius(double value)
         {
-            return new SpecificEntropy(joulesperkilogramdegreecelsius, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.JoulePerKilogramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromJoulesPerKilogramKelvin(double joulesperkilogramkelvin)
+        public static SpecificEntropy FromJoulesPerKilogramKelvin(double value)
         {
-            return new SpecificEntropy(joulesperkilogramkelvin, SpecificEntropyUnit.JoulePerKilogramKelvin);
+            return new SpecificEntropy(value, SpecificEntropyUnit.JoulePerKilogramKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilocaloriePerGramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilocaloriesPerGramKelvin(double kilocaloriespergramkelvin)
+        public static SpecificEntropy FromKilocaloriesPerGramKelvin(double value)
         {
-            return new SpecificEntropy(kilocaloriespergramkelvin, SpecificEntropyUnit.KilocaloriePerGramKelvin);
+            return new SpecificEntropy(value, SpecificEntropyUnit.KilocaloriePerGramKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(double kilojoulesperkilogramdegreecelsius)
+        public static SpecificEntropy FromKilojoulesPerKilogramDegreeCelsius(double value)
         {
-            return new SpecificEntropy(kilojoulesperkilogramdegreecelsius, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.KilojoulePerKilogramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromKilojoulesPerKilogramKelvin(double kilojoulesperkilogramkelvin)
+        public static SpecificEntropy FromKilojoulesPerKilogramKelvin(double value)
         {
-            return new SpecificEntropy(kilojoulesperkilogramkelvin, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
+            return new SpecificEntropy(value, SpecificEntropyUnit.KilojoulePerKilogramKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(double megajoulesperkilogramdegreecelsius)
+        public static SpecificEntropy FromMegajoulesPerKilogramDegreeCelsius(double value)
         {
-            return new SpecificEntropy(megajoulesperkilogramdegreecelsius, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
+            return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificEntropy"/> from <see cref="SpecificEntropyUnit.MegajoulePerKilogramKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificEntropy FromMegajoulesPerKilogramKelvin(double megajoulesperkilogramkelvin)
+        public static SpecificEntropy FromMegajoulesPerKilogramKelvin(double value)
         {
-            return new SpecificEntropy(megajoulesperkilogramkelvin, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
+            return new SpecificEntropy(value, SpecificEntropyUnit.MegajoulePerKilogramKelvin);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
index f98426d202..9e0b0ddcb3 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificFuelConsumption.g.cs
@@ -248,36 +248,36 @@ public static string GetAbbreviation(SpecificFuelConsumptionUnit unit, IFormatPr
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificFuelConsumption FromGramsPerKiloNewtonSecond(double gramsperkilonewtonsecond)
+        public static SpecificFuelConsumption FromGramsPerKiloNewtonSecond(double value)
         {
-            return new SpecificFuelConsumption(gramsperkilonewtonsecond, SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond);
+            return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.GramPerKiloNewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(double kilogramsperkilogramforcehour)
+        public static SpecificFuelConsumption FromKilogramsPerKilogramForceHour(double value)
         {
-            return new SpecificFuelConsumption(kilogramsperkilogramforcehour, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
+            return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKilogramForceHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificFuelConsumption FromKilogramsPerKiloNewtonSecond(double kilogramsperkilonewtonsecond)
+        public static SpecificFuelConsumption FromKilogramsPerKiloNewtonSecond(double value)
         {
-            return new SpecificFuelConsumption(kilogramsperkilonewtonsecond, SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond);
+            return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.KilogramPerKiloNewtonSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificFuelConsumption"/> from <see cref="SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(double poundsmassperpoundforcehour)
+        public static SpecificFuelConsumption FromPoundsMassPerPoundForceHour(double value)
         {
-            return new SpecificFuelConsumption(poundsmassperpoundforcehour, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
+            return new SpecificFuelConsumption(value, SpecificFuelConsumptionUnit.PoundMassPerPoundForceHour);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
index ec08b56d95..511ee26cc2 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificVolume.g.cs
@@ -243,27 +243,27 @@ public static string GetAbbreviation(SpecificVolumeUnit unit, IFormatProvider? p
         ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicFootPerPound"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromCubicFeetPerPound(double cubicfeetperpound)
+        public static SpecificVolume FromCubicFeetPerPound(double value)
         {
-            return new SpecificVolume(cubicfeetperpound, SpecificVolumeUnit.CubicFootPerPound);
+            return new SpecificVolume(value, SpecificVolumeUnit.CubicFootPerPound);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.CubicMeterPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromCubicMetersPerKilogram(double cubicmetersperkilogram)
+        public static SpecificVolume FromCubicMetersPerKilogram(double value)
         {
-            return new SpecificVolume(cubicmetersperkilogram, SpecificVolumeUnit.CubicMeterPerKilogram);
+            return new SpecificVolume(value, SpecificVolumeUnit.CubicMeterPerKilogram);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificVolume"/> from <see cref="SpecificVolumeUnit.MillicubicMeterPerKilogram"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificVolume FromMillicubicMetersPerKilogram(double millicubicmetersperkilogram)
+        public static SpecificVolume FromMillicubicMetersPerKilogram(double value)
         {
-            return new SpecificVolume(millicubicmetersperkilogram, SpecificVolumeUnit.MillicubicMeterPerKilogram);
+            return new SpecificVolume(value, SpecificVolumeUnit.MillicubicMeterPerKilogram);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
index 1c863125ad..df6748a31f 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
@@ -361,153 +361,153 @@ public static string GetAbbreviation(SpecificWeightUnit unit, IFormatProvider? p
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicCentimeter(double kilogramsforcepercubiccentimeter)
+        public static SpecificWeight FromKilogramsForcePerCubicCentimeter(double value)
         {
-            return new SpecificWeight(kilogramsforcepercubiccentimeter, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
+            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicMeter(double kilogramsforcepercubicmeter)
+        public static SpecificWeight FromKilogramsForcePerCubicMeter(double value)
         {
-            return new SpecificWeight(kilogramsforcepercubicmeter, SpecificWeightUnit.KilogramForcePerCubicMeter);
+            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilogramForcePerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilogramsForcePerCubicMillimeter(double kilogramsforcepercubicmillimeter)
+        public static SpecificWeight FromKilogramsForcePerCubicMillimeter(double value)
         {
-            return new SpecificWeight(kilogramsforcepercubicmillimeter, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
+            return new SpecificWeight(value, SpecificWeightUnit.KilogramForcePerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicCentimeter(double kilonewtonspercubiccentimeter)
+        public static SpecificWeight FromKilonewtonsPerCubicCentimeter(double value)
         {
-            return new SpecificWeight(kilonewtonspercubiccentimeter, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
+            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicMeter(double kilonewtonspercubicmeter)
+        public static SpecificWeight FromKilonewtonsPerCubicMeter(double value)
         {
-            return new SpecificWeight(kilonewtonspercubicmeter, SpecificWeightUnit.KilonewtonPerCubicMeter);
+            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilonewtonPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilonewtonsPerCubicMillimeter(double kilonewtonspercubicmillimeter)
+        public static SpecificWeight FromKilonewtonsPerCubicMillimeter(double value)
         {
-            return new SpecificWeight(kilonewtonspercubicmillimeter, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
+            return new SpecificWeight(value, SpecificWeightUnit.KilonewtonPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilopoundForcePerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilopoundsForcePerCubicFoot(double kilopoundsforcepercubicfoot)
+        public static SpecificWeight FromKilopoundsForcePerCubicFoot(double value)
         {
-            return new SpecificWeight(kilopoundsforcepercubicfoot, SpecificWeightUnit.KilopoundForcePerCubicFoot);
+            return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.KilopoundForcePerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromKilopoundsForcePerCubicInch(double kilopoundsforcepercubicinch)
+        public static SpecificWeight FromKilopoundsForcePerCubicInch(double value)
         {
-            return new SpecificWeight(kilopoundsforcepercubicinch, SpecificWeightUnit.KilopoundForcePerCubicInch);
+            return new SpecificWeight(value, SpecificWeightUnit.KilopoundForcePerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.MeganewtonPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromMeganewtonsPerCubicMeter(double meganewtonspercubicmeter)
+        public static SpecificWeight FromMeganewtonsPerCubicMeter(double value)
         {
-            return new SpecificWeight(meganewtonspercubicmeter, SpecificWeightUnit.MeganewtonPerCubicMeter);
+            return new SpecificWeight(value, SpecificWeightUnit.MeganewtonPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicCentimeter(double newtonspercubiccentimeter)
+        public static SpecificWeight FromNewtonsPerCubicCentimeter(double value)
         {
-            return new SpecificWeight(newtonspercubiccentimeter, SpecificWeightUnit.NewtonPerCubicCentimeter);
+            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicMeter(double newtonspercubicmeter)
+        public static SpecificWeight FromNewtonsPerCubicMeter(double value)
         {
-            return new SpecificWeight(newtonspercubicmeter, SpecificWeightUnit.NewtonPerCubicMeter);
+            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.NewtonPerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromNewtonsPerCubicMillimeter(double newtonspercubicmillimeter)
+        public static SpecificWeight FromNewtonsPerCubicMillimeter(double value)
         {
-            return new SpecificWeight(newtonspercubicmillimeter, SpecificWeightUnit.NewtonPerCubicMillimeter);
+            return new SpecificWeight(value, SpecificWeightUnit.NewtonPerCubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.PoundForcePerCubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromPoundsForcePerCubicFoot(double poundsforcepercubicfoot)
+        public static SpecificWeight FromPoundsForcePerCubicFoot(double value)
         {
-            return new SpecificWeight(poundsforcepercubicfoot, SpecificWeightUnit.PoundForcePerCubicFoot);
+            return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.PoundForcePerCubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromPoundsForcePerCubicInch(double poundsforcepercubicinch)
+        public static SpecificWeight FromPoundsForcePerCubicInch(double value)
         {
-            return new SpecificWeight(poundsforcepercubicinch, SpecificWeightUnit.PoundForcePerCubicInch);
+            return new SpecificWeight(value, SpecificWeightUnit.PoundForcePerCubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicCentimeter(double tonnesforcepercubiccentimeter)
+        public static SpecificWeight FromTonnesForcePerCubicCentimeter(double value)
         {
-            return new SpecificWeight(tonnesforcepercubiccentimeter, SpecificWeightUnit.TonneForcePerCubicCentimeter);
+            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicMeter(double tonnesforcepercubicmeter)
+        public static SpecificWeight FromTonnesForcePerCubicMeter(double value)
         {
-            return new SpecificWeight(tonnesforcepercubicmeter, SpecificWeightUnit.TonneForcePerCubicMeter);
+            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="SpecificWeight"/> from <see cref="SpecificWeightUnit.TonneForcePerCubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static SpecificWeight FromTonnesForcePerCubicMillimeter(double tonnesforcepercubicmillimeter)
+        public static SpecificWeight FromTonnesForcePerCubicMillimeter(double value)
         {
-            return new SpecificWeight(tonnesforcepercubicmillimeter, SpecificWeightUnit.TonneForcePerCubicMillimeter);
+            return new SpecificWeight(value, SpecificWeightUnit.TonneForcePerCubicMillimeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
index 8bf4d96a66..be123e3c16 100644
--- a/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Speed.g.cs
@@ -492,297 +492,297 @@ public static string GetAbbreviation(SpeedUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerHour(double centimetersperhour)
+        public static Speed FromCentimetersPerHour(double value)
         {
-            return new Speed(centimetersperhour, SpeedUnit.CentimeterPerHour);
+            return new Speed(value, SpeedUnit.CentimeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerMinute(double centimetersperminute)
+        public static Speed FromCentimetersPerMinute(double value)
         {
-            return new Speed(centimetersperminute, SpeedUnit.CentimeterPerMinute);
+            return new Speed(value, SpeedUnit.CentimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.CentimeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromCentimetersPerSecond(double centimeterspersecond)
+        public static Speed FromCentimetersPerSecond(double value)
         {
-            return new Speed(centimeterspersecond, SpeedUnit.CentimeterPerSecond);
+            return new Speed(value, SpeedUnit.CentimeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.DecimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromDecimetersPerMinute(double decimetersperminute)
+        public static Speed FromDecimetersPerMinute(double value)
         {
-            return new Speed(decimetersperminute, SpeedUnit.DecimeterPerMinute);
+            return new Speed(value, SpeedUnit.DecimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.DecimeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromDecimetersPerSecond(double decimeterspersecond)
+        public static Speed FromDecimetersPerSecond(double value)
         {
-            return new Speed(decimeterspersecond, SpeedUnit.DecimeterPerSecond);
+            return new Speed(value, SpeedUnit.DecimeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerHour(double feetperhour)
+        public static Speed FromFeetPerHour(double value)
         {
-            return new Speed(feetperhour, SpeedUnit.FootPerHour);
+            return new Speed(value, SpeedUnit.FootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerMinute(double feetperminute)
+        public static Speed FromFeetPerMinute(double value)
         {
-            return new Speed(feetperminute, SpeedUnit.FootPerMinute);
+            return new Speed(value, SpeedUnit.FootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.FootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromFeetPerSecond(double feetpersecond)
+        public static Speed FromFeetPerSecond(double value)
         {
-            return new Speed(feetpersecond, SpeedUnit.FootPerSecond);
+            return new Speed(value, SpeedUnit.FootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerHour(double inchesperhour)
+        public static Speed FromInchesPerHour(double value)
         {
-            return new Speed(inchesperhour, SpeedUnit.InchPerHour);
+            return new Speed(value, SpeedUnit.InchPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerMinute(double inchesperminute)
+        public static Speed FromInchesPerMinute(double value)
         {
-            return new Speed(inchesperminute, SpeedUnit.InchPerMinute);
+            return new Speed(value, SpeedUnit.InchPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.InchPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromInchesPerSecond(double inchespersecond)
+        public static Speed FromInchesPerSecond(double value)
         {
-            return new Speed(inchespersecond, SpeedUnit.InchPerSecond);
+            return new Speed(value, SpeedUnit.InchPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerHour(double kilometersperhour)
+        public static Speed FromKilometersPerHour(double value)
         {
-            return new Speed(kilometersperhour, SpeedUnit.KilometerPerHour);
+            return new Speed(value, SpeedUnit.KilometerPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerMinute(double kilometersperminute)
+        public static Speed FromKilometersPerMinute(double value)
         {
-            return new Speed(kilometersperminute, SpeedUnit.KilometerPerMinute);
+            return new Speed(value, SpeedUnit.KilometerPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.KilometerPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKilometersPerSecond(double kilometerspersecond)
+        public static Speed FromKilometersPerSecond(double value)
         {
-            return new Speed(kilometerspersecond, SpeedUnit.KilometerPerSecond);
+            return new Speed(value, SpeedUnit.KilometerPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.Knot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromKnots(double knots)
+        public static Speed FromKnots(double value)
         {
-            return new Speed(knots, SpeedUnit.Knot);
+            return new Speed(value, SpeedUnit.Knot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.Mach"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMach(double mach)
+        public static Speed FromMach(double value)
         {
-            return new Speed(mach, SpeedUnit.Mach);
+            return new Speed(value, SpeedUnit.Mach);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerHour(double metersperhour)
+        public static Speed FromMetersPerHour(double value)
         {
-            return new Speed(metersperhour, SpeedUnit.MeterPerHour);
+            return new Speed(value, SpeedUnit.MeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerMinute(double metersperminute)
+        public static Speed FromMetersPerMinute(double value)
         {
-            return new Speed(metersperminute, SpeedUnit.MeterPerMinute);
+            return new Speed(value, SpeedUnit.MeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMetersPerSecond(double meterspersecond)
+        public static Speed FromMetersPerSecond(double value)
         {
-            return new Speed(meterspersecond, SpeedUnit.MeterPerSecond);
+            return new Speed(value, SpeedUnit.MeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MicrometerPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMicrometersPerMinute(double micrometersperminute)
+        public static Speed FromMicrometersPerMinute(double value)
         {
-            return new Speed(micrometersperminute, SpeedUnit.MicrometerPerMinute);
+            return new Speed(value, SpeedUnit.MicrometerPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MicrometerPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMicrometersPerSecond(double micrometerspersecond)
+        public static Speed FromMicrometersPerSecond(double value)
         {
-            return new Speed(micrometerspersecond, SpeedUnit.MicrometerPerSecond);
+            return new Speed(value, SpeedUnit.MicrometerPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MilePerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMilesPerHour(double milesperhour)
+        public static Speed FromMilesPerHour(double value)
         {
-            return new Speed(milesperhour, SpeedUnit.MilePerHour);
+            return new Speed(value, SpeedUnit.MilePerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerHour(double millimetersperhour)
+        public static Speed FromMillimetersPerHour(double value)
         {
-            return new Speed(millimetersperhour, SpeedUnit.MillimeterPerHour);
+            return new Speed(value, SpeedUnit.MillimeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerMinute(double millimetersperminute)
+        public static Speed FromMillimetersPerMinute(double value)
         {
-            return new Speed(millimetersperminute, SpeedUnit.MillimeterPerMinute);
+            return new Speed(value, SpeedUnit.MillimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.MillimeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromMillimetersPerSecond(double millimeterspersecond)
+        public static Speed FromMillimetersPerSecond(double value)
         {
-            return new Speed(millimeterspersecond, SpeedUnit.MillimeterPerSecond);
+            return new Speed(value, SpeedUnit.MillimeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.NanometerPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromNanometersPerMinute(double nanometersperminute)
+        public static Speed FromNanometersPerMinute(double value)
         {
-            return new Speed(nanometersperminute, SpeedUnit.NanometerPerMinute);
+            return new Speed(value, SpeedUnit.NanometerPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.NanometerPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromNanometersPerSecond(double nanometerspersecond)
+        public static Speed FromNanometersPerSecond(double value)
         {
-            return new Speed(nanometerspersecond, SpeedUnit.NanometerPerSecond);
+            return new Speed(value, SpeedUnit.NanometerPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerHour(double ussurveyfeetperhour)
+        public static Speed FromUsSurveyFeetPerHour(double value)
         {
-            return new Speed(ussurveyfeetperhour, SpeedUnit.UsSurveyFootPerHour);
+            return new Speed(value, SpeedUnit.UsSurveyFootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerMinute(double ussurveyfeetperminute)
+        public static Speed FromUsSurveyFeetPerMinute(double value)
         {
-            return new Speed(ussurveyfeetperminute, SpeedUnit.UsSurveyFootPerMinute);
+            return new Speed(value, SpeedUnit.UsSurveyFootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.UsSurveyFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromUsSurveyFeetPerSecond(double ussurveyfeetpersecond)
+        public static Speed FromUsSurveyFeetPerSecond(double value)
         {
-            return new Speed(ussurveyfeetpersecond, SpeedUnit.UsSurveyFootPerSecond);
+            return new Speed(value, SpeedUnit.UsSurveyFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerHour(double yardsperhour)
+        public static Speed FromYardsPerHour(double value)
         {
-            return new Speed(yardsperhour, SpeedUnit.YardPerHour);
+            return new Speed(value, SpeedUnit.YardPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerMinute(double yardsperminute)
+        public static Speed FromYardsPerMinute(double value)
         {
-            return new Speed(yardsperminute, SpeedUnit.YardPerMinute);
+            return new Speed(value, SpeedUnit.YardPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="Speed"/> from <see cref="SpeedUnit.YardPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Speed FromYardsPerSecond(double yardspersecond)
+        public static Speed FromYardsPerSecond(double value)
         {
-            return new Speed(yardspersecond, SpeedUnit.YardPerSecond);
+            return new Speed(value, SpeedUnit.YardPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
index b5667ffc11..556efa1c3c 100644
--- a/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/StandardVolumeFlow.g.cs
@@ -285,81 +285,81 @@ public static string GetAbbreviation(StandardVolumeFlowUnit unit, IFormatProvide
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(double standardcubiccentimetersperminute)
+        public static StandardVolumeFlow FromStandardCubicCentimetersPerMinute(double value)
         {
-            return new StandardVolumeFlow(standardcubiccentimetersperminute, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicCentimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicFeetPerHour(double standardcubicfeetperhour)
+        public static StandardVolumeFlow FromStandardCubicFeetPerHour(double value)
         {
-            return new StandardVolumeFlow(standardcubicfeetperhour, StandardVolumeFlowUnit.StandardCubicFootPerHour);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicFeetPerMinute(double standardcubicfeetperminute)
+        public static StandardVolumeFlow FromStandardCubicFeetPerMinute(double value)
         {
-            return new StandardVolumeFlow(standardcubicfeetperminute, StandardVolumeFlowUnit.StandardCubicFootPerMinute);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicFeetPerSecond(double standardcubicfeetpersecond)
+        public static StandardVolumeFlow FromStandardCubicFeetPerSecond(double value)
         {
-            return new StandardVolumeFlow(standardcubicfeetpersecond, StandardVolumeFlowUnit.StandardCubicFootPerSecond);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicMetersPerDay(double standardcubicmetersperday)
+        public static StandardVolumeFlow FromStandardCubicMetersPerDay(double value)
         {
-            return new StandardVolumeFlow(standardcubicmetersperday, StandardVolumeFlowUnit.StandardCubicMeterPerDay);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicMetersPerHour(double standardcubicmetersperhour)
+        public static StandardVolumeFlow FromStandardCubicMetersPerHour(double value)
         {
-            return new StandardVolumeFlow(standardcubicmetersperhour, StandardVolumeFlowUnit.StandardCubicMeterPerHour);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicMetersPerMinute(double standardcubicmetersperminute)
+        public static StandardVolumeFlow FromStandardCubicMetersPerMinute(double value)
         {
-            return new StandardVolumeFlow(standardcubicmetersperminute, StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardCubicMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardCubicMetersPerSecond(double standardcubicmeterspersecond)
+        public static StandardVolumeFlow FromStandardCubicMetersPerSecond(double value)
         {
-            return new StandardVolumeFlow(standardcubicmeterspersecond, StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardCubicMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="StandardVolumeFlow"/> from <see cref="StandardVolumeFlowUnit.StandardLiterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static StandardVolumeFlow FromStandardLitersPerMinute(double standardlitersperminute)
+        public static StandardVolumeFlow FromStandardLitersPerMinute(double value)
         {
-            return new StandardVolumeFlow(standardlitersperminute, StandardVolumeFlowUnit.StandardLiterPerMinute);
+            return new StandardVolumeFlow(value, StandardVolumeFlowUnit.StandardLiterPerMinute);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
index c3d224ce77..4afd8ff8ca 100644
--- a/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Temperature.g.cs
@@ -290,90 +290,90 @@ public static string GetAbbreviation(TemperatureUnit unit, IFormatProvider? prov
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesCelsius(double degreescelsius)
+        public static Temperature FromDegreesCelsius(double value)
         {
-            return new Temperature(degreescelsius, TemperatureUnit.DegreeCelsius);
+            return new Temperature(value, TemperatureUnit.DegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeDelisle"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesDelisle(double degreesdelisle)
+        public static Temperature FromDegreesDelisle(double value)
         {
-            return new Temperature(degreesdelisle, TemperatureUnit.DegreeDelisle);
+            return new Temperature(value, TemperatureUnit.DegreeDelisle);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesFahrenheit(double degreesfahrenheit)
+        public static Temperature FromDegreesFahrenheit(double value)
         {
-            return new Temperature(degreesfahrenheit, TemperatureUnit.DegreeFahrenheit);
+            return new Temperature(value, TemperatureUnit.DegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeNewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesNewton(double degreesnewton)
+        public static Temperature FromDegreesNewton(double value)
         {
-            return new Temperature(degreesnewton, TemperatureUnit.DegreeNewton);
+            return new Temperature(value, TemperatureUnit.DegreeNewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeRankine"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesRankine(double degreesrankine)
+        public static Temperature FromDegreesRankine(double value)
         {
-            return new Temperature(degreesrankine, TemperatureUnit.DegreeRankine);
+            return new Temperature(value, TemperatureUnit.DegreeRankine);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeReaumur"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesReaumur(double degreesreaumur)
+        public static Temperature FromDegreesReaumur(double value)
         {
-            return new Temperature(degreesreaumur, TemperatureUnit.DegreeReaumur);
+            return new Temperature(value, TemperatureUnit.DegreeReaumur);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.DegreeRoemer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromDegreesRoemer(double degreesroemer)
+        public static Temperature FromDegreesRoemer(double value)
         {
-            return new Temperature(degreesroemer, TemperatureUnit.DegreeRoemer);
+            return new Temperature(value, TemperatureUnit.DegreeRoemer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.Kelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromKelvins(double kelvins)
+        public static Temperature FromKelvins(double value)
         {
-            return new Temperature(kelvins, TemperatureUnit.Kelvin);
+            return new Temperature(value, TemperatureUnit.Kelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.MillidegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromMillidegreesCelsius(double millidegreescelsius)
+        public static Temperature FromMillidegreesCelsius(double value)
         {
-            return new Temperature(millidegreescelsius, TemperatureUnit.MillidegreeCelsius);
+            return new Temperature(value, TemperatureUnit.MillidegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="Temperature"/> from <see cref="TemperatureUnit.SolarTemperature"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Temperature FromSolarTemperatures(double solartemperatures)
+        public static Temperature FromSolarTemperatures(double value)
         {
-            return new Temperature(solartemperatures, TemperatureUnit.SolarTemperature);
+            return new Temperature(value, TemperatureUnit.SolarTemperature);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
index e50c577e4d..d11a02f09f 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureChangeRate.g.cs
@@ -300,90 +300,90 @@ public static string GetAbbreviation(TemperatureChangeRateUnit unit, IFormatProv
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(double centidegreescelsiuspersecond)
+        public static TemperatureChangeRate FromCentidegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(centidegreescelsiuspersecond, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.CentidegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(double decadegreescelsiuspersecond)
+        public static TemperatureChangeRate FromDecadegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(decadegreescelsiuspersecond, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecadegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(double decidegreescelsiuspersecond)
+        public static TemperatureChangeRate FromDecidegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(decidegreescelsiuspersecond, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DecidegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDegreesCelsiusPerMinute(double degreescelsiusperminute)
+        public static TemperatureChangeRate FromDegreesCelsiusPerMinute(double value)
         {
-            return new TemperatureChangeRate(degreescelsiusperminute, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.DegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromDegreesCelsiusPerSecond(double degreescelsiuspersecond)
+        public static TemperatureChangeRate FromDegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(degreescelsiuspersecond, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.DegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(double hectodegreescelsiuspersecond)
+        public static TemperatureChangeRate FromHectodegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(hectodegreescelsiuspersecond, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.HectodegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(double kilodegreescelsiuspersecond)
+        public static TemperatureChangeRate FromKilodegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(kilodegreescelsiuspersecond, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.KilodegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(double microdegreescelsiuspersecond)
+        public static TemperatureChangeRate FromMicrodegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(microdegreescelsiuspersecond, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MicrodegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(double millidegreescelsiuspersecond)
+        public static TemperatureChangeRate FromMillidegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(millidegreescelsiuspersecond, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.MillidegreeCelsiusPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureChangeRate"/> from <see cref="TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double nanodegreescelsiuspersecond)
+        public static TemperatureChangeRate FromNanodegreesCelsiusPerSecond(double value)
         {
-            return new TemperatureChangeRate(nanodegreescelsiuspersecond, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
+            return new TemperatureChangeRate(value, TemperatureChangeRateUnit.NanodegreeCelsiusPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
index ea0728ccc2..ac4bc1b2b9 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureDelta.g.cs
@@ -295,81 +295,81 @@ public static string GetAbbreviation(TemperatureDeltaUnit unit, IFormatProvider?
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesCelsius(double degreescelsius)
+        public static TemperatureDelta FromDegreesCelsius(double value)
         {
-            return new TemperatureDelta(degreescelsius, TemperatureDeltaUnit.DegreeCelsius);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeDelisle"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesDelisle(double degreesdelisle)
+        public static TemperatureDelta FromDegreesDelisle(double value)
         {
-            return new TemperatureDelta(degreesdelisle, TemperatureDeltaUnit.DegreeDelisle);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeDelisle);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesFahrenheit(double degreesfahrenheit)
+        public static TemperatureDelta FromDegreesFahrenheit(double value)
         {
-            return new TemperatureDelta(degreesfahrenheit, TemperatureDeltaUnit.DegreeFahrenheit);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeNewton"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesNewton(double degreesnewton)
+        public static TemperatureDelta FromDegreesNewton(double value)
         {
-            return new TemperatureDelta(degreesnewton, TemperatureDeltaUnit.DegreeNewton);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeNewton);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeRankine"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesRankine(double degreesrankine)
+        public static TemperatureDelta FromDegreesRankine(double value)
         {
-            return new TemperatureDelta(degreesrankine, TemperatureDeltaUnit.DegreeRankine);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRankine);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeReaumur"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesReaumur(double degreesreaumur)
+        public static TemperatureDelta FromDegreesReaumur(double value)
         {
-            return new TemperatureDelta(degreesreaumur, TemperatureDeltaUnit.DegreeReaumur);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeReaumur);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.DegreeRoemer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromDegreesRoemer(double degreesroemer)
+        public static TemperatureDelta FromDegreesRoemer(double value)
         {
-            return new TemperatureDelta(degreesroemer, TemperatureDeltaUnit.DegreeRoemer);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.DegreeRoemer);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.Kelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromKelvins(double kelvins)
+        public static TemperatureDelta FromKelvins(double value)
         {
-            return new TemperatureDelta(kelvins, TemperatureDeltaUnit.Kelvin);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.Kelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureDelta"/> from <see cref="TemperatureDeltaUnit.MillidegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureDelta FromMillidegreesCelsius(double millidegreescelsius)
+        public static TemperatureDelta FromMillidegreesCelsius(double value)
         {
-            return new TemperatureDelta(millidegreescelsius, TemperatureDeltaUnit.MillidegreeCelsius);
+            return new TemperatureDelta(value, TemperatureDeltaUnit.MillidegreeCelsius);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
index bd3d6405be..887514b5c0 100644
--- a/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TemperatureGradient.g.cs
@@ -251,36 +251,36 @@ public static string GetAbbreviation(TemperatureGradientUnit unit, IFormatProvid
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeCelsiusPerKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureGradient FromDegreesCelsiusPerKilometer(double degreescelsiusperkilometer)
+        public static TemperatureGradient FromDegreesCelsiusPerKilometer(double value)
         {
-            return new TemperatureGradient(degreescelsiusperkilometer, TemperatureGradientUnit.DegreeCelsiusPerKilometer);
+            return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeCelsiusPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureGradient FromDegreesCelsiusPerMeter(double degreescelsiuspermeter)
+        public static TemperatureGradient FromDegreesCelsiusPerMeter(double value)
         {
-            return new TemperatureGradient(degreescelsiuspermeter, TemperatureGradientUnit.DegreeCelsiusPerMeter);
+            return new TemperatureGradient(value, TemperatureGradientUnit.DegreeCelsiusPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.DegreeFahrenheitPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureGradient FromDegreesFahrenheitPerFoot(double degreesfahrenheitperfoot)
+        public static TemperatureGradient FromDegreesFahrenheitPerFoot(double value)
         {
-            return new TemperatureGradient(degreesfahrenheitperfoot, TemperatureGradientUnit.DegreeFahrenheitPerFoot);
+            return new TemperatureGradient(value, TemperatureGradientUnit.DegreeFahrenheitPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TemperatureGradient"/> from <see cref="TemperatureGradientUnit.KelvinPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TemperatureGradient FromKelvinsPerMeter(double kelvinspermeter)
+        public static TemperatureGradient FromKelvinsPerMeter(double value)
         {
-            return new TemperatureGradient(kelvinspermeter, TemperatureGradientUnit.KelvinPerMeter);
+            return new TemperatureGradient(value, TemperatureGradientUnit.KelvinPerMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
index 7d523f9769..b3f9368f74 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalConductivity.g.cs
@@ -232,18 +232,18 @@ public static string GetAbbreviation(ThermalConductivityUnit unit, IFormatProvid
         ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.BtuPerHourFootFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalConductivity FromBtusPerHourFootFahrenheit(double btusperhourfootfahrenheit)
+        public static ThermalConductivity FromBtusPerHourFootFahrenheit(double value)
         {
-            return new ThermalConductivity(btusperhourfootfahrenheit, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
+            return new ThermalConductivity(value, ThermalConductivityUnit.BtuPerHourFootFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalConductivity"/> from <see cref="ThermalConductivityUnit.WattPerMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalConductivity FromWattsPerMeterKelvin(double wattspermeterkelvin)
+        public static ThermalConductivity FromWattsPerMeterKelvin(double value)
         {
-            return new ThermalConductivity(wattspermeterkelvin, ThermalConductivityUnit.WattPerMeterKelvin);
+            return new ThermalConductivity(value, ThermalConductivityUnit.WattPerMeterKelvin);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
index d22876e53d..83fd1625b9 100644
--- a/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ThermalResistance.g.cs
@@ -261,54 +261,54 @@ public static string GetAbbreviation(ThermalResistanceUnit unit, IFormatProvider
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(double hoursquarefeetdegreesfahrenheitperbtu)
+        public static ThermalResistance FromHourSquareFeetDegreesFahrenheitPerBtu(double value)
         {
-            return new ThermalResistance(hoursquarefeetdegreesfahrenheitperbtu, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
+            return new ThermalResistance(value, ThermalResistanceUnit.HourSquareFeetDegreeFahrenheitPerBtu);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double squarecentimeterhourdegreescelsiusperkilocalorie)
+        public static ThermalResistance FromSquareCentimeterHourDegreesCelsiusPerKilocalorie(double value)
         {
-            return new ThermalResistance(squarecentimeterhourdegreescelsiusperkilocalorie, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
+            return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterHourDegreeCelsiusPerKilocalorie);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareCentimeterKelvinPerWatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(double squarecentimeterkelvinsperwatt)
+        public static ThermalResistance FromSquareCentimeterKelvinsPerWatt(double value)
         {
-            return new ThermalResistance(squarecentimeterkelvinsperwatt, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
+            return new ThermalResistance(value, ThermalResistanceUnit.SquareCentimeterKelvinPerWatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(double squaremeterdegreescelsiusperwatt)
+        public static ThermalResistance FromSquareMeterDegreesCelsiusPerWatt(double value)
         {
-            return new ThermalResistance(squaremeterdegreescelsiusperwatt, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
+            return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterDegreeCelsiusPerWatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareMeterKelvinPerKilowatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(double squaremeterkelvinsperkilowatt)
+        public static ThermalResistance FromSquareMeterKelvinsPerKilowatt(double value)
         {
-            return new ThermalResistance(squaremeterkelvinsperkilowatt, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
+            return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerKilowatt);
         }
 
         /// <summary>
         ///     Creates a <see cref="ThermalResistance"/> from <see cref="ThermalResistanceUnit.SquareMeterKelvinPerWatt"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static ThermalResistance FromSquareMeterKelvinsPerWatt(double squaremeterkelvinsperwatt)
+        public static ThermalResistance FromSquareMeterKelvinsPerWatt(double value)
         {
-            return new ThermalResistance(squaremeterkelvinsperwatt, ThermalResistanceUnit.SquareMeterKelvinPerWatt);
+            return new ThermalResistance(value, ThermalResistanceUnit.SquareMeterKelvinPerWatt);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
index 1541850784..c03eb9fc7f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Torque.g.cs
@@ -422,225 +422,225 @@ public static string GetAbbreviation(TorqueUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromGramForceCentimeters(double gramforcecentimeters)
+        public static Torque FromGramForceCentimeters(double value)
         {
-            return new Torque(gramforcecentimeters, TorqueUnit.GramForceCentimeter);
+            return new Torque(value, TorqueUnit.GramForceCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromGramForceMeters(double gramforcemeters)
+        public static Torque FromGramForceMeters(double value)
         {
-            return new Torque(gramforcemeters, TorqueUnit.GramForceMeter);
+            return new Torque(value, TorqueUnit.GramForceMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.GramForceMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromGramForceMillimeters(double gramforcemillimeters)
+        public static Torque FromGramForceMillimeters(double value)
         {
-            return new Torque(gramforcemillimeters, TorqueUnit.GramForceMillimeter);
+            return new Torque(value, TorqueUnit.GramForceMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceCentimeters(double kilogramforcecentimeters)
+        public static Torque FromKilogramForceCentimeters(double value)
         {
-            return new Torque(kilogramforcecentimeters, TorqueUnit.KilogramForceCentimeter);
+            return new Torque(value, TorqueUnit.KilogramForceCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceMeters(double kilogramforcemeters)
+        public static Torque FromKilogramForceMeters(double value)
         {
-            return new Torque(kilogramforcemeters, TorqueUnit.KilogramForceMeter);
+            return new Torque(value, TorqueUnit.KilogramForceMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilogramForceMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilogramForceMillimeters(double kilogramforcemillimeters)
+        public static Torque FromKilogramForceMillimeters(double value)
         {
-            return new Torque(kilogramforcemillimeters, TorqueUnit.KilogramForceMillimeter);
+            return new Torque(value, TorqueUnit.KilogramForceMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonCentimeters(double kilonewtoncentimeters)
+        public static Torque FromKilonewtonCentimeters(double value)
         {
-            return new Torque(kilonewtoncentimeters, TorqueUnit.KilonewtonCentimeter);
+            return new Torque(value, TorqueUnit.KilonewtonCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonMeters(double kilonewtonmeters)
+        public static Torque FromKilonewtonMeters(double value)
         {
-            return new Torque(kilonewtonmeters, TorqueUnit.KilonewtonMeter);
+            return new Torque(value, TorqueUnit.KilonewtonMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilonewtonMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilonewtonMillimeters(double kilonewtonmillimeters)
+        public static Torque FromKilonewtonMillimeters(double value)
         {
-            return new Torque(kilonewtonmillimeters, TorqueUnit.KilonewtonMillimeter);
+            return new Torque(value, TorqueUnit.KilonewtonMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilopoundForceFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilopoundForceFeet(double kilopoundforcefeet)
+        public static Torque FromKilopoundForceFeet(double value)
         {
-            return new Torque(kilopoundforcefeet, TorqueUnit.KilopoundForceFoot);
+            return new Torque(value, TorqueUnit.KilopoundForceFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.KilopoundForceInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromKilopoundForceInches(double kilopoundforceinches)
+        public static Torque FromKilopoundForceInches(double value)
         {
-            return new Torque(kilopoundforceinches, TorqueUnit.KilopoundForceInch);
+            return new Torque(value, TorqueUnit.KilopoundForceInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonCentimeters(double meganewtoncentimeters)
+        public static Torque FromMeganewtonCentimeters(double value)
         {
-            return new Torque(meganewtoncentimeters, TorqueUnit.MeganewtonCentimeter);
+            return new Torque(value, TorqueUnit.MeganewtonCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonMeters(double meganewtonmeters)
+        public static Torque FromMeganewtonMeters(double value)
         {
-            return new Torque(meganewtonmeters, TorqueUnit.MeganewtonMeter);
+            return new Torque(value, TorqueUnit.MeganewtonMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MeganewtonMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMeganewtonMillimeters(double meganewtonmillimeters)
+        public static Torque FromMeganewtonMillimeters(double value)
         {
-            return new Torque(meganewtonmillimeters, TorqueUnit.MeganewtonMillimeter);
+            return new Torque(value, TorqueUnit.MeganewtonMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MegapoundForceFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMegapoundForceFeet(double megapoundforcefeet)
+        public static Torque FromMegapoundForceFeet(double value)
         {
-            return new Torque(megapoundforcefeet, TorqueUnit.MegapoundForceFoot);
+            return new Torque(value, TorqueUnit.MegapoundForceFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.MegapoundForceInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromMegapoundForceInches(double megapoundforceinches)
+        public static Torque FromMegapoundForceInches(double value)
         {
-            return new Torque(megapoundforceinches, TorqueUnit.MegapoundForceInch);
+            return new Torque(value, TorqueUnit.MegapoundForceInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonCentimeters(double newtoncentimeters)
+        public static Torque FromNewtonCentimeters(double value)
         {
-            return new Torque(newtoncentimeters, TorqueUnit.NewtonCentimeter);
+            return new Torque(value, TorqueUnit.NewtonCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonMeters(double newtonmeters)
+        public static Torque FromNewtonMeters(double value)
         {
-            return new Torque(newtonmeters, TorqueUnit.NewtonMeter);
+            return new Torque(value, TorqueUnit.NewtonMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.NewtonMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromNewtonMillimeters(double newtonmillimeters)
+        public static Torque FromNewtonMillimeters(double value)
         {
-            return new Torque(newtonmillimeters, TorqueUnit.NewtonMillimeter);
+            return new Torque(value, TorqueUnit.NewtonMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundalFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundalFeet(double poundalfeet)
+        public static Torque FromPoundalFeet(double value)
         {
-            return new Torque(poundalfeet, TorqueUnit.PoundalFoot);
+            return new Torque(value, TorqueUnit.PoundalFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundForceFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundForceFeet(double poundforcefeet)
+        public static Torque FromPoundForceFeet(double value)
         {
-            return new Torque(poundforcefeet, TorqueUnit.PoundForceFoot);
+            return new Torque(value, TorqueUnit.PoundForceFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.PoundForceInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromPoundForceInches(double poundforceinches)
+        public static Torque FromPoundForceInches(double value)
         {
-            return new Torque(poundforceinches, TorqueUnit.PoundForceInch);
+            return new Torque(value, TorqueUnit.PoundForceInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceCentimeters(double tonneforcecentimeters)
+        public static Torque FromTonneForceCentimeters(double value)
         {
-            return new Torque(tonneforcecentimeters, TorqueUnit.TonneForceCentimeter);
+            return new Torque(value, TorqueUnit.TonneForceCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceMeters(double tonneforcemeters)
+        public static Torque FromTonneForceMeters(double value)
         {
-            return new Torque(tonneforcemeters, TorqueUnit.TonneForceMeter);
+            return new Torque(value, TorqueUnit.TonneForceMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Torque"/> from <see cref="TorqueUnit.TonneForceMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Torque FromTonneForceMillimeters(double tonneforcemillimeters)
+        public static Torque FromTonneForceMillimeters(double value)
         {
-            return new Torque(tonneforcemillimeters, TorqueUnit.TonneForceMillimeter);
+            return new Torque(value, TorqueUnit.TonneForceMillimeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
index 3324414983..2f9e92a03d 100644
--- a/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/TorquePerLength.g.cs
@@ -381,189 +381,189 @@ public static string GetAbbreviation(TorquePerLengthUnit unit, IFormatProvider?
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilogramForceCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceCentimetersPerMeter(double kilogramforcecentimeterspermeter)
+        public static TorquePerLength FromKilogramForceCentimetersPerMeter(double value)
         {
-            return new TorquePerLength(kilogramforcecentimeterspermeter, TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilogramForceMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceMetersPerMeter(double kilogramforcemeterspermeter)
+        public static TorquePerLength FromKilogramForceMetersPerMeter(double value)
         {
-            return new TorquePerLength(kilogramforcemeterspermeter, TorquePerLengthUnit.KilogramForceMeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilogramForceMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilogramForceMillimetersPerMeter(double kilogramforcemillimeterspermeter)
+        public static TorquePerLength FromKilogramForceMillimetersPerMeter(double value)
         {
-            return new TorquePerLength(kilogramforcemillimeterspermeter, TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.KilogramForceMillimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilonewtonCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonCentimetersPerMeter(double kilonewtoncentimeterspermeter)
+        public static TorquePerLength FromKilonewtonCentimetersPerMeter(double value)
         {
-            return new TorquePerLength(kilonewtoncentimeterspermeter, TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilonewtonMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonMetersPerMeter(double kilonewtonmeterspermeter)
+        public static TorquePerLength FromKilonewtonMetersPerMeter(double value)
         {
-            return new TorquePerLength(kilonewtonmeterspermeter, TorquePerLengthUnit.KilonewtonMeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilonewtonMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilonewtonMillimetersPerMeter(double kilonewtonmillimeterspermeter)
+        public static TorquePerLength FromKilonewtonMillimetersPerMeter(double value)
         {
-            return new TorquePerLength(kilonewtonmillimeterspermeter, TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.KilonewtonMillimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilopoundForceFootPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilopoundForceFeetPerFoot(double kilopoundforcefeetperfoot)
+        public static TorquePerLength FromKilopoundForceFeetPerFoot(double value)
         {
-            return new TorquePerLength(kilopoundforcefeetperfoot, TorquePerLengthUnit.KilopoundForceFootPerFoot);
+            return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceFootPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.KilopoundForceInchPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromKilopoundForceInchesPerFoot(double kilopoundforceinchesperfoot)
+        public static TorquePerLength FromKilopoundForceInchesPerFoot(double value)
         {
-            return new TorquePerLength(kilopoundforceinchesperfoot, TorquePerLengthUnit.KilopoundForceInchPerFoot);
+            return new TorquePerLength(value, TorquePerLengthUnit.KilopoundForceInchPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MeganewtonCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonCentimetersPerMeter(double meganewtoncentimeterspermeter)
+        public static TorquePerLength FromMeganewtonCentimetersPerMeter(double value)
         {
-            return new TorquePerLength(meganewtoncentimeterspermeter, TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MeganewtonMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonMetersPerMeter(double meganewtonmeterspermeter)
+        public static TorquePerLength FromMeganewtonMetersPerMeter(double value)
         {
-            return new TorquePerLength(meganewtonmeterspermeter, TorquePerLengthUnit.MeganewtonMeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MeganewtonMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMeganewtonMillimetersPerMeter(double meganewtonmillimeterspermeter)
+        public static TorquePerLength FromMeganewtonMillimetersPerMeter(double value)
         {
-            return new TorquePerLength(meganewtonmillimeterspermeter, TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.MeganewtonMillimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MegapoundForceFootPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMegapoundForceFeetPerFoot(double megapoundforcefeetperfoot)
+        public static TorquePerLength FromMegapoundForceFeetPerFoot(double value)
         {
-            return new TorquePerLength(megapoundforcefeetperfoot, TorquePerLengthUnit.MegapoundForceFootPerFoot);
+            return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceFootPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.MegapoundForceInchPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromMegapoundForceInchesPerFoot(double megapoundforceinchesperfoot)
+        public static TorquePerLength FromMegapoundForceInchesPerFoot(double value)
         {
-            return new TorquePerLength(megapoundforceinchesperfoot, TorquePerLengthUnit.MegapoundForceInchPerFoot);
+            return new TorquePerLength(value, TorquePerLengthUnit.MegapoundForceInchPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.NewtonCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonCentimetersPerMeter(double newtoncentimeterspermeter)
+        public static TorquePerLength FromNewtonCentimetersPerMeter(double value)
         {
-            return new TorquePerLength(newtoncentimeterspermeter, TorquePerLengthUnit.NewtonCentimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.NewtonCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.NewtonMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonMetersPerMeter(double newtonmeterspermeter)
+        public static TorquePerLength FromNewtonMetersPerMeter(double value)
         {
-            return new TorquePerLength(newtonmeterspermeter, TorquePerLengthUnit.NewtonMeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.NewtonMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.NewtonMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromNewtonMillimetersPerMeter(double newtonmillimeterspermeter)
+        public static TorquePerLength FromNewtonMillimetersPerMeter(double value)
         {
-            return new TorquePerLength(newtonmillimeterspermeter, TorquePerLengthUnit.NewtonMillimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.NewtonMillimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.PoundForceFootPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromPoundForceFeetPerFoot(double poundforcefeetperfoot)
+        public static TorquePerLength FromPoundForceFeetPerFoot(double value)
         {
-            return new TorquePerLength(poundforcefeetperfoot, TorquePerLengthUnit.PoundForceFootPerFoot);
+            return new TorquePerLength(value, TorquePerLengthUnit.PoundForceFootPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.PoundForceInchPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromPoundForceInchesPerFoot(double poundforceinchesperfoot)
+        public static TorquePerLength FromPoundForceInchesPerFoot(double value)
         {
-            return new TorquePerLength(poundforceinchesperfoot, TorquePerLengthUnit.PoundForceInchPerFoot);
+            return new TorquePerLength(value, TorquePerLengthUnit.PoundForceInchPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.TonneForceCentimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceCentimetersPerMeter(double tonneforcecentimeterspermeter)
+        public static TorquePerLength FromTonneForceCentimetersPerMeter(double value)
         {
-            return new TorquePerLength(tonneforcecentimeterspermeter, TorquePerLengthUnit.TonneForceCentimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceCentimeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.TonneForceMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceMetersPerMeter(double tonneforcemeterspermeter)
+        public static TorquePerLength FromTonneForceMetersPerMeter(double value)
         {
-            return new TorquePerLength(tonneforcemeterspermeter, TorquePerLengthUnit.TonneForceMeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="TorquePerLength"/> from <see cref="TorquePerLengthUnit.TonneForceMillimeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static TorquePerLength FromTonneForceMillimetersPerMeter(double tonneforcemillimeterspermeter)
+        public static TorquePerLength FromTonneForceMillimetersPerMeter(double value)
         {
-            return new TorquePerLength(tonneforcemillimeterspermeter, TorquePerLengthUnit.TonneForceMillimeterPerMeter);
+            return new TorquePerLength(value, TorquePerLengthUnit.TonneForceMillimeterPerMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
index ab02056d19..429be531e2 100644
--- a/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Turbidity.g.cs
@@ -224,9 +224,9 @@ public static string GetAbbreviation(TurbidityUnit unit, IFormatProvider? provid
         ///     Creates a <see cref="Turbidity"/> from <see cref="TurbidityUnit.NTU"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Turbidity FromNTU(double ntu)
+        public static Turbidity FromNTU(double value)
         {
-            return new Turbidity(ntu, TurbidityUnit.NTU);
+            return new Turbidity(value, TurbidityUnit.NTU);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
index dbfacd2822..21481bfd60 100644
--- a/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VitaminA.g.cs
@@ -221,9 +221,9 @@ public static string GetAbbreviation(VitaminAUnit unit, IFormatProvider? provide
         ///     Creates a <see cref="VitaminA"/> from <see cref="VitaminAUnit.InternationalUnit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VitaminA FromInternationalUnits(double internationalunits)
+        public static VitaminA FromInternationalUnits(double value)
         {
-            return new VitaminA(internationalunits, VitaminAUnit.InternationalUnit);
+            return new VitaminA(value, VitaminAUnit.InternationalUnit);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
index 130cbc626b..ed7177bf43 100644
--- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
@@ -657,486 +657,486 @@ public static string GetAbbreviation(VolumeUnit unit, IFormatProvider? provider)
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.AcreFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromAcreFeet(double acrefeet)
+        public static Volume FromAcreFeet(double value)
         {
-            return new Volume(acrefeet, VolumeUnit.AcreFoot);
+            return new Volume(value, VolumeUnit.AcreFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.AuTablespoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromAuTablespoons(double autablespoons)
+        public static Volume FromAuTablespoons(double value)
         {
-            return new Volume(autablespoons, VolumeUnit.AuTablespoon);
+            return new Volume(value, VolumeUnit.AuTablespoon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.BoardFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromBoardFeet(double boardfeet)
+        public static Volume FromBoardFeet(double value)
         {
-            return new Volume(boardfeet, VolumeUnit.BoardFoot);
+            return new Volume(value, VolumeUnit.BoardFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Centiliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCentiliters(double centiliters)
+        public static Volume FromCentiliters(double value)
         {
-            return new Volume(centiliters, VolumeUnit.Centiliter);
+            return new Volume(value, VolumeUnit.Centiliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicCentimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicCentimeters(double cubiccentimeters)
+        public static Volume FromCubicCentimeters(double value)
         {
-            return new Volume(cubiccentimeters, VolumeUnit.CubicCentimeter);
+            return new Volume(value, VolumeUnit.CubicCentimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicDecimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicDecimeters(double cubicdecimeters)
+        public static Volume FromCubicDecimeters(double value)
         {
-            return new Volume(cubicdecimeters, VolumeUnit.CubicDecimeter);
+            return new Volume(value, VolumeUnit.CubicDecimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicFeet(double cubicfeet)
+        public static Volume FromCubicFeet(double value)
         {
-            return new Volume(cubicfeet, VolumeUnit.CubicFoot);
+            return new Volume(value, VolumeUnit.CubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicHectometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicHectometers(double cubichectometers)
+        public static Volume FromCubicHectometers(double value)
         {
-            return new Volume(cubichectometers, VolumeUnit.CubicHectometer);
+            return new Volume(value, VolumeUnit.CubicHectometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicInch"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicInches(double cubicinches)
+        public static Volume FromCubicInches(double value)
         {
-            return new Volume(cubicinches, VolumeUnit.CubicInch);
+            return new Volume(value, VolumeUnit.CubicInch);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicKilometers(double cubickilometers)
+        public static Volume FromCubicKilometers(double value)
         {
-            return new Volume(cubickilometers, VolumeUnit.CubicKilometer);
+            return new Volume(value, VolumeUnit.CubicKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMeters(double cubicmeters)
+        public static Volume FromCubicMeters(double value)
         {
-            return new Volume(cubicmeters, VolumeUnit.CubicMeter);
+            return new Volume(value, VolumeUnit.CubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMicrometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMicrometers(double cubicmicrometers)
+        public static Volume FromCubicMicrometers(double value)
         {
-            return new Volume(cubicmicrometers, VolumeUnit.CubicMicrometer);
+            return new Volume(value, VolumeUnit.CubicMicrometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMiles(double cubicmiles)
+        public static Volume FromCubicMiles(double value)
         {
-            return new Volume(cubicmiles, VolumeUnit.CubicMile);
+            return new Volume(value, VolumeUnit.CubicMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicMillimeters(double cubicmillimeters)
+        public static Volume FromCubicMillimeters(double value)
         {
-            return new Volume(cubicmillimeters, VolumeUnit.CubicMillimeter);
+            return new Volume(value, VolumeUnit.CubicMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.CubicYard"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromCubicYards(double cubicyards)
+        public static Volume FromCubicYards(double value)
         {
-            return new Volume(cubicyards, VolumeUnit.CubicYard);
+            return new Volume(value, VolumeUnit.CubicYard);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Decaliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDecaliters(double decaliters)
+        public static Volume FromDecaliters(double value)
         {
-            return new Volume(decaliters, VolumeUnit.Decaliter);
+            return new Volume(value, VolumeUnit.Decaliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.DecausGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDecausGallons(double decausgallons)
+        public static Volume FromDecausGallons(double value)
         {
-            return new Volume(decausgallons, VolumeUnit.DecausGallon);
+            return new Volume(value, VolumeUnit.DecausGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Deciliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDeciliters(double deciliters)
+        public static Volume FromDeciliters(double value)
         {
-            return new Volume(deciliters, VolumeUnit.Deciliter);
+            return new Volume(value, VolumeUnit.Deciliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.DeciusGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromDeciusGallons(double deciusgallons)
+        public static Volume FromDeciusGallons(double value)
         {
-            return new Volume(deciusgallons, VolumeUnit.DeciusGallon);
+            return new Volume(value, VolumeUnit.DeciusGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectocubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectocubicFeet(double hectocubicfeet)
+        public static Volume FromHectocubicFeet(double value)
         {
-            return new Volume(hectocubicfeet, VolumeUnit.HectocubicFoot);
+            return new Volume(value, VolumeUnit.HectocubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectocubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectocubicMeters(double hectocubicmeters)
+        public static Volume FromHectocubicMeters(double value)
         {
-            return new Volume(hectocubicmeters, VolumeUnit.HectocubicMeter);
+            return new Volume(value, VolumeUnit.HectocubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Hectoliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectoliters(double hectoliters)
+        public static Volume FromHectoliters(double value)
         {
-            return new Volume(hectoliters, VolumeUnit.Hectoliter);
+            return new Volume(value, VolumeUnit.Hectoliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.HectousGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromHectousGallons(double hectousgallons)
+        public static Volume FromHectousGallons(double value)
         {
-            return new Volume(hectousgallons, VolumeUnit.HectousGallon);
+            return new Volume(value, VolumeUnit.HectousGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialBeerBarrel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialBeerBarrels(double imperialbeerbarrels)
+        public static Volume FromImperialBeerBarrels(double value)
         {
-            return new Volume(imperialbeerbarrels, VolumeUnit.ImperialBeerBarrel);
+            return new Volume(value, VolumeUnit.ImperialBeerBarrel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialGallons(double imperialgallons)
+        public static Volume FromImperialGallons(double value)
         {
-            return new Volume(imperialgallons, VolumeUnit.ImperialGallon);
+            return new Volume(value, VolumeUnit.ImperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialOunce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialOunces(double imperialounces)
+        public static Volume FromImperialOunces(double value)
         {
-            return new Volume(imperialounces, VolumeUnit.ImperialOunce);
+            return new Volume(value, VolumeUnit.ImperialOunce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialPint"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialPints(double imperialpints)
+        public static Volume FromImperialPints(double value)
         {
-            return new Volume(imperialpints, VolumeUnit.ImperialPint);
+            return new Volume(value, VolumeUnit.ImperialPint);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.ImperialQuart"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromImperialQuarts(double imperialquarts)
+        public static Volume FromImperialQuarts(double value)
         {
-            return new Volume(imperialquarts, VolumeUnit.ImperialQuart);
+            return new Volume(value, VolumeUnit.ImperialQuart);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilocubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilocubicFeet(double kilocubicfeet)
+        public static Volume FromKilocubicFeet(double value)
         {
-            return new Volume(kilocubicfeet, VolumeUnit.KilocubicFoot);
+            return new Volume(value, VolumeUnit.KilocubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilocubicMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilocubicMeters(double kilocubicmeters)
+        public static Volume FromKilocubicMeters(double value)
         {
-            return new Volume(kilocubicmeters, VolumeUnit.KilocubicMeter);
+            return new Volume(value, VolumeUnit.KilocubicMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KiloimperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKiloimperialGallons(double kiloimperialgallons)
+        public static Volume FromKiloimperialGallons(double value)
         {
-            return new Volume(kiloimperialgallons, VolumeUnit.KiloimperialGallon);
+            return new Volume(value, VolumeUnit.KiloimperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Kiloliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKiloliters(double kiloliters)
+        public static Volume FromKiloliters(double value)
         {
-            return new Volume(kiloliters, VolumeUnit.Kiloliter);
+            return new Volume(value, VolumeUnit.Kiloliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.KilousGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromKilousGallons(double kilousgallons)
+        public static Volume FromKilousGallons(double value)
         {
-            return new Volume(kilousgallons, VolumeUnit.KilousGallon);
+            return new Volume(value, VolumeUnit.KilousGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Liter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromLiters(double liters)
+        public static Volume FromLiters(double value)
         {
-            return new Volume(liters, VolumeUnit.Liter);
+            return new Volume(value, VolumeUnit.Liter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegacubicFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegacubicFeet(double megacubicfeet)
+        public static Volume FromMegacubicFeet(double value)
         {
-            return new Volume(megacubicfeet, VolumeUnit.MegacubicFoot);
+            return new Volume(value, VolumeUnit.MegacubicFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegaimperialGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegaimperialGallons(double megaimperialgallons)
+        public static Volume FromMegaimperialGallons(double value)
         {
-            return new Volume(megaimperialgallons, VolumeUnit.MegaimperialGallon);
+            return new Volume(value, VolumeUnit.MegaimperialGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Megaliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegaliters(double megaliters)
+        public static Volume FromMegaliters(double value)
         {
-            return new Volume(megaliters, VolumeUnit.Megaliter);
+            return new Volume(value, VolumeUnit.Megaliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MegausGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMegausGallons(double megausgallons)
+        public static Volume FromMegausGallons(double value)
         {
-            return new Volume(megausgallons, VolumeUnit.MegausGallon);
+            return new Volume(value, VolumeUnit.MegausGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricCup"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMetricCups(double metriccups)
+        public static Volume FromMetricCups(double value)
         {
-            return new Volume(metriccups, VolumeUnit.MetricCup);
+            return new Volume(value, VolumeUnit.MetricCup);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.MetricTeaspoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMetricTeaspoons(double metricteaspoons)
+        public static Volume FromMetricTeaspoons(double value)
         {
-            return new Volume(metricteaspoons, VolumeUnit.MetricTeaspoon);
+            return new Volume(value, VolumeUnit.MetricTeaspoon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Microliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMicroliters(double microliters)
+        public static Volume FromMicroliters(double value)
         {
-            return new Volume(microliters, VolumeUnit.Microliter);
+            return new Volume(value, VolumeUnit.Microliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Milliliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromMilliliters(double milliliters)
+        public static Volume FromMilliliters(double value)
         {
-            return new Volume(milliliters, VolumeUnit.Milliliter);
+            return new Volume(value, VolumeUnit.Milliliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.Nanoliter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromNanoliters(double nanoliters)
+        public static Volume FromNanoliters(double value)
         {
-            return new Volume(nanoliters, VolumeUnit.Nanoliter);
+            return new Volume(value, VolumeUnit.Nanoliter);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.OilBarrel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromOilBarrels(double oilbarrels)
+        public static Volume FromOilBarrels(double value)
         {
-            return new Volume(oilbarrels, VolumeUnit.OilBarrel);
+            return new Volume(value, VolumeUnit.OilBarrel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UkTablespoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUkTablespoons(double uktablespoons)
+        public static Volume FromUkTablespoons(double value)
         {
-            return new Volume(uktablespoons, VolumeUnit.UkTablespoon);
+            return new Volume(value, VolumeUnit.UkTablespoon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsBeerBarrel"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsBeerBarrels(double usbeerbarrels)
+        public static Volume FromUsBeerBarrels(double value)
         {
-            return new Volume(usbeerbarrels, VolumeUnit.UsBeerBarrel);
+            return new Volume(value, VolumeUnit.UsBeerBarrel);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsCustomaryCup"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsCustomaryCups(double uscustomarycups)
+        public static Volume FromUsCustomaryCups(double value)
         {
-            return new Volume(uscustomarycups, VolumeUnit.UsCustomaryCup);
+            return new Volume(value, VolumeUnit.UsCustomaryCup);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsGallon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsGallons(double usgallons)
+        public static Volume FromUsGallons(double value)
         {
-            return new Volume(usgallons, VolumeUnit.UsGallon);
+            return new Volume(value, VolumeUnit.UsGallon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsLegalCup"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsLegalCups(double uslegalcups)
+        public static Volume FromUsLegalCups(double value)
         {
-            return new Volume(uslegalcups, VolumeUnit.UsLegalCup);
+            return new Volume(value, VolumeUnit.UsLegalCup);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsOunce"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsOunces(double usounces)
+        public static Volume FromUsOunces(double value)
         {
-            return new Volume(usounces, VolumeUnit.UsOunce);
+            return new Volume(value, VolumeUnit.UsOunce);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsPint"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsPints(double uspints)
+        public static Volume FromUsPints(double value)
         {
-            return new Volume(uspints, VolumeUnit.UsPint);
+            return new Volume(value, VolumeUnit.UsPint);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsQuart"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsQuarts(double usquarts)
+        public static Volume FromUsQuarts(double value)
         {
-            return new Volume(usquarts, VolumeUnit.UsQuart);
+            return new Volume(value, VolumeUnit.UsQuart);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsTablespoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsTablespoons(double ustablespoons)
+        public static Volume FromUsTablespoons(double value)
         {
-            return new Volume(ustablespoons, VolumeUnit.UsTablespoon);
+            return new Volume(value, VolumeUnit.UsTablespoon);
         }
 
         /// <summary>
         ///     Creates a <see cref="Volume"/> from <see cref="VolumeUnit.UsTeaspoon"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static Volume FromUsTeaspoons(double usteaspoons)
+        public static Volume FromUsTeaspoons(double value)
         {
-            return new Volume(usteaspoons, VolumeUnit.UsTeaspoon);
+            return new Volume(value, VolumeUnit.UsTeaspoon);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
index af7057eac6..4cdee12390 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeConcentration.g.cs
@@ -383,180 +383,180 @@ public static string GetAbbreviation(VolumeConcentrationUnit unit, IFormatProvid
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.CentilitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromCentilitersPerLiter(double centilitersperliter)
+        public static VolumeConcentration FromCentilitersPerLiter(double value)
         {
-            return new VolumeConcentration(centilitersperliter, VolumeConcentrationUnit.CentilitersPerLiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.CentilitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromCentilitersPerMililiter(double centiliterspermililiter)
+        public static VolumeConcentration FromCentilitersPerMililiter(double value)
         {
-            return new VolumeConcentration(centiliterspermililiter, VolumeConcentrationUnit.CentilitersPerMililiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.CentilitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DecilitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecilitersPerLiter(double decilitersperliter)
+        public static VolumeConcentration FromDecilitersPerLiter(double value)
         {
-            return new VolumeConcentration(decilitersperliter, VolumeConcentrationUnit.DecilitersPerLiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DecilitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecilitersPerMililiter(double deciliterspermililiter)
+        public static VolumeConcentration FromDecilitersPerMililiter(double value)
         {
-            return new VolumeConcentration(deciliterspermililiter, VolumeConcentrationUnit.DecilitersPerMililiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.DecilitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.DecimalFraction"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromDecimalFractions(double decimalfractions)
+        public static VolumeConcentration FromDecimalFractions(double value)
         {
-            return new VolumeConcentration(decimalfractions, VolumeConcentrationUnit.DecimalFraction);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.DecimalFraction);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.LitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromLitersPerLiter(double litersperliter)
+        public static VolumeConcentration FromLitersPerLiter(double value)
         {
-            return new VolumeConcentration(litersperliter, VolumeConcentrationUnit.LitersPerLiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.LitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromLitersPerMililiter(double literspermililiter)
+        public static VolumeConcentration FromLitersPerMililiter(double value)
         {
-            return new VolumeConcentration(literspermililiter, VolumeConcentrationUnit.LitersPerMililiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.LitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MicrolitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMicrolitersPerLiter(double microlitersperliter)
+        public static VolumeConcentration FromMicrolitersPerLiter(double value)
         {
-            return new VolumeConcentration(microlitersperliter, VolumeConcentrationUnit.MicrolitersPerLiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MicrolitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMicrolitersPerMililiter(double microliterspermililiter)
+        public static VolumeConcentration FromMicrolitersPerMililiter(double value)
         {
-            return new VolumeConcentration(microliterspermililiter, VolumeConcentrationUnit.MicrolitersPerMililiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.MicrolitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MillilitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMillilitersPerLiter(double millilitersperliter)
+        public static VolumeConcentration FromMillilitersPerLiter(double value)
         {
-            return new VolumeConcentration(millilitersperliter, VolumeConcentrationUnit.MillilitersPerLiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.MillilitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromMillilitersPerMililiter(double milliliterspermililiter)
+        public static VolumeConcentration FromMillilitersPerMililiter(double value)
         {
-            return new VolumeConcentration(milliliterspermililiter, VolumeConcentrationUnit.MillilitersPerMililiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.MillilitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.NanolitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromNanolitersPerLiter(double nanolitersperliter)
+        public static VolumeConcentration FromNanolitersPerLiter(double value)
         {
-            return new VolumeConcentration(nanolitersperliter, VolumeConcentrationUnit.NanolitersPerLiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.NanolitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromNanolitersPerMililiter(double nanoliterspermililiter)
+        public static VolumeConcentration FromNanolitersPerMililiter(double value)
         {
-            return new VolumeConcentration(nanoliterspermililiter, VolumeConcentrationUnit.NanolitersPerMililiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.NanolitersPerMililiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerBillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerBillion(double partsperbillion)
+        public static VolumeConcentration FromPartsPerBillion(double value)
         {
-            return new VolumeConcentration(partsperbillion, VolumeConcentrationUnit.PartPerBillion);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerBillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerMillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerMillion(double partspermillion)
+        public static VolumeConcentration FromPartsPerMillion(double value)
         {
-            return new VolumeConcentration(partspermillion, VolumeConcentrationUnit.PartPerMillion);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerMillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerThousand"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerThousand(double partsperthousand)
+        public static VolumeConcentration FromPartsPerThousand(double value)
         {
-            return new VolumeConcentration(partsperthousand, VolumeConcentrationUnit.PartPerThousand);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerThousand);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PartPerTrillion"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPartsPerTrillion(double partspertrillion)
+        public static VolumeConcentration FromPartsPerTrillion(double value)
         {
-            return new VolumeConcentration(partspertrillion, VolumeConcentrationUnit.PartPerTrillion);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.PartPerTrillion);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.Percent"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPercent(double percent)
+        public static VolumeConcentration FromPercent(double value)
         {
-            return new VolumeConcentration(percent, VolumeConcentrationUnit.Percent);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.Percent);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PicolitersPerLiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPicolitersPerLiter(double picolitersperliter)
+        public static VolumeConcentration FromPicolitersPerLiter(double value)
         {
-            return new VolumeConcentration(picolitersperliter, VolumeConcentrationUnit.PicolitersPerLiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerLiter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeConcentration"/> from <see cref="VolumeConcentrationUnit.PicolitersPerMililiter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeConcentration FromPicolitersPerMililiter(double picoliterspermililiter)
+        public static VolumeConcentration FromPicolitersPerMililiter(double value)
         {
-            return new VolumeConcentration(picoliterspermililiter, VolumeConcentrationUnit.PicolitersPerMililiter);
+            return new VolumeConcentration(value, VolumeConcentrationUnit.PicolitersPerMililiter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
index 9431de6549..9f224a0c95 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlow.g.cs
@@ -759,603 +759,603 @@ public static string GetAbbreviation(VolumeFlowUnit unit, IFormatProvider? provi
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerDay(double acrefeetperday)
+        public static VolumeFlow FromAcreFeetPerDay(double value)
         {
-            return new VolumeFlow(acrefeetperday, VolumeFlowUnit.AcreFootPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerHour(double acrefeetperhour)
+        public static VolumeFlow FromAcreFeetPerHour(double value)
         {
-            return new VolumeFlow(acrefeetperhour, VolumeFlowUnit.AcreFootPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerMinute(double acrefeetperminute)
+        public static VolumeFlow FromAcreFeetPerMinute(double value)
         {
-            return new VolumeFlow(acrefeetperminute, VolumeFlowUnit.AcreFootPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.AcreFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromAcreFeetPerSecond(double acrefeetpersecond)
+        public static VolumeFlow FromAcreFeetPerSecond(double value)
         {
-            return new VolumeFlow(acrefeetpersecond, VolumeFlowUnit.AcreFootPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.AcreFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerDay(double centilitersperday)
+        public static VolumeFlow FromCentilitersPerDay(double value)
         {
-            return new VolumeFlow(centilitersperday, VolumeFlowUnit.CentiliterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerHour(double centilitersperhour)
+        public static VolumeFlow FromCentilitersPerHour(double value)
         {
-            return new VolumeFlow(centilitersperhour, VolumeFlowUnit.CentiliterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerMinute(double centilitersperminute)
+        public static VolumeFlow FromCentilitersPerMinute(double value)
         {
-            return new VolumeFlow(centilitersperminute, VolumeFlowUnit.CentiliterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CentiliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCentilitersPerSecond(double centiliterspersecond)
+        public static VolumeFlow FromCentilitersPerSecond(double value)
         {
-            return new VolumeFlow(centiliterspersecond, VolumeFlowUnit.CentiliterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.CentiliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicCentimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicCentimetersPerMinute(double cubiccentimetersperminute)
+        public static VolumeFlow FromCubicCentimetersPerMinute(double value)
         {
-            return new VolumeFlow(cubiccentimetersperminute, VolumeFlowUnit.CubicCentimeterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicCentimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicDecimeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicDecimetersPerMinute(double cubicdecimetersperminute)
+        public static VolumeFlow FromCubicDecimetersPerMinute(double value)
         {
-            return new VolumeFlow(cubicdecimetersperminute, VolumeFlowUnit.CubicDecimeterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicDecimeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerHour(double cubicfeetperhour)
+        public static VolumeFlow FromCubicFeetPerHour(double value)
         {
-            return new VolumeFlow(cubicfeetperhour, VolumeFlowUnit.CubicFootPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerMinute(double cubicfeetperminute)
+        public static VolumeFlow FromCubicFeetPerMinute(double value)
         {
-            return new VolumeFlow(cubicfeetperminute, VolumeFlowUnit.CubicFootPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicFootPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicFeetPerSecond(double cubicfeetpersecond)
+        public static VolumeFlow FromCubicFeetPerSecond(double value)
         {
-            return new VolumeFlow(cubicfeetpersecond, VolumeFlowUnit.CubicFootPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicFootPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerDay(double cubicmetersperday)
+        public static VolumeFlow FromCubicMetersPerDay(double value)
         {
-            return new VolumeFlow(cubicmetersperday, VolumeFlowUnit.CubicMeterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerHour(double cubicmetersperhour)
+        public static VolumeFlow FromCubicMetersPerHour(double value)
         {
-            return new VolumeFlow(cubicmetersperhour, VolumeFlowUnit.CubicMeterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerMinute(double cubicmetersperminute)
+        public static VolumeFlow FromCubicMetersPerMinute(double value)
         {
-            return new VolumeFlow(cubicmetersperminute, VolumeFlowUnit.CubicMeterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMetersPerSecond(double cubicmeterspersecond)
+        public static VolumeFlow FromCubicMetersPerSecond(double value)
         {
-            return new VolumeFlow(cubicmeterspersecond, VolumeFlowUnit.CubicMeterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicMeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicMillimeterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicMillimetersPerSecond(double cubicmillimeterspersecond)
+        public static VolumeFlow FromCubicMillimetersPerSecond(double value)
         {
-            return new VolumeFlow(cubicmillimeterspersecond, VolumeFlowUnit.CubicMillimeterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicMillimeterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerDay(double cubicyardsperday)
+        public static VolumeFlow FromCubicYardsPerDay(double value)
         {
-            return new VolumeFlow(cubicyardsperday, VolumeFlowUnit.CubicYardPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerHour(double cubicyardsperhour)
+        public static VolumeFlow FromCubicYardsPerHour(double value)
         {
-            return new VolumeFlow(cubicyardsperhour, VolumeFlowUnit.CubicYardPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerMinute(double cubicyardsperminute)
+        public static VolumeFlow FromCubicYardsPerMinute(double value)
         {
-            return new VolumeFlow(cubicyardsperminute, VolumeFlowUnit.CubicYardPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.CubicYardPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromCubicYardsPerSecond(double cubicyardspersecond)
+        public static VolumeFlow FromCubicYardsPerSecond(double value)
         {
-            return new VolumeFlow(cubicyardspersecond, VolumeFlowUnit.CubicYardPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.CubicYardPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerDay(double decilitersperday)
+        public static VolumeFlow FromDecilitersPerDay(double value)
         {
-            return new VolumeFlow(decilitersperday, VolumeFlowUnit.DeciliterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerHour(double decilitersperhour)
+        public static VolumeFlow FromDecilitersPerHour(double value)
         {
-            return new VolumeFlow(decilitersperhour, VolumeFlowUnit.DeciliterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerMinute(double decilitersperminute)
+        public static VolumeFlow FromDecilitersPerMinute(double value)
         {
-            return new VolumeFlow(decilitersperminute, VolumeFlowUnit.DeciliterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.DeciliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromDecilitersPerSecond(double deciliterspersecond)
+        public static VolumeFlow FromDecilitersPerSecond(double value)
         {
-            return new VolumeFlow(deciliterspersecond, VolumeFlowUnit.DeciliterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.DeciliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerDay(double kilolitersperday)
+        public static VolumeFlow FromKilolitersPerDay(double value)
         {
-            return new VolumeFlow(kilolitersperday, VolumeFlowUnit.KiloliterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerHour(double kilolitersperhour)
+        public static VolumeFlow FromKilolitersPerHour(double value)
         {
-            return new VolumeFlow(kilolitersperhour, VolumeFlowUnit.KiloliterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerMinute(double kilolitersperminute)
+        public static VolumeFlow FromKilolitersPerMinute(double value)
         {
-            return new VolumeFlow(kilolitersperminute, VolumeFlowUnit.KiloliterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KiloliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilolitersPerSecond(double kiloliterspersecond)
+        public static VolumeFlow FromKilolitersPerSecond(double value)
         {
-            return new VolumeFlow(kiloliterspersecond, VolumeFlowUnit.KiloliterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.KiloliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.KilousGallonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromKilousGallonsPerMinute(double kilousgallonsperminute)
+        public static VolumeFlow FromKilousGallonsPerMinute(double value)
         {
-            return new VolumeFlow(kilousgallonsperminute, VolumeFlowUnit.KilousGallonPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.KilousGallonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerDay(double litersperday)
+        public static VolumeFlow FromLitersPerDay(double value)
         {
-            return new VolumeFlow(litersperday, VolumeFlowUnit.LiterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.LiterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerHour(double litersperhour)
+        public static VolumeFlow FromLitersPerHour(double value)
         {
-            return new VolumeFlow(litersperhour, VolumeFlowUnit.LiterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.LiterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerMinute(double litersperminute)
+        public static VolumeFlow FromLitersPerMinute(double value)
         {
-            return new VolumeFlow(litersperminute, VolumeFlowUnit.LiterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.LiterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.LiterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromLitersPerSecond(double literspersecond)
+        public static VolumeFlow FromLitersPerSecond(double value)
         {
-            return new VolumeFlow(literspersecond, VolumeFlowUnit.LiterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.LiterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerDay(double megalitersperday)
+        public static VolumeFlow FromMegalitersPerDay(double value)
         {
-            return new VolumeFlow(megalitersperday, VolumeFlowUnit.MegaliterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerHour(double megalitersperhour)
+        public static VolumeFlow FromMegalitersPerHour(double value)
         {
-            return new VolumeFlow(megalitersperhour, VolumeFlowUnit.MegaliterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerMinute(double megalitersperminute)
+        public static VolumeFlow FromMegalitersPerMinute(double value)
         {
-            return new VolumeFlow(megalitersperminute, VolumeFlowUnit.MegaliterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegalitersPerSecond(double megaliterspersecond)
+        public static VolumeFlow FromMegalitersPerSecond(double value)
         {
-            return new VolumeFlow(megaliterspersecond, VolumeFlowUnit.MegaliterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.MegaliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaukGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegaukGallonsPerDay(double megaukgallonsperday)
+        public static VolumeFlow FromMegaukGallonsPerDay(double value)
         {
-            return new VolumeFlow(megaukgallonsperday, VolumeFlowUnit.MegaukGallonPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegaukGallonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegaukGallonsPerSecond(double megaukgallonspersecond)
+        public static VolumeFlow FromMegaukGallonsPerSecond(double value)
         {
-            return new VolumeFlow(megaukgallonspersecond, VolumeFlowUnit.MegaukGallonPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.MegaukGallonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MegausGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMegausGallonsPerDay(double megausgallonsperday)
+        public static VolumeFlow FromMegausGallonsPerDay(double value)
         {
-            return new VolumeFlow(megausgallonsperday, VolumeFlowUnit.MegausGallonPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.MegausGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerDay(double microlitersperday)
+        public static VolumeFlow FromMicrolitersPerDay(double value)
         {
-            return new VolumeFlow(microlitersperday, VolumeFlowUnit.MicroliterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerHour(double microlitersperhour)
+        public static VolumeFlow FromMicrolitersPerHour(double value)
         {
-            return new VolumeFlow(microlitersperhour, VolumeFlowUnit.MicroliterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerMinute(double microlitersperminute)
+        public static VolumeFlow FromMicrolitersPerMinute(double value)
         {
-            return new VolumeFlow(microlitersperminute, VolumeFlowUnit.MicroliterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MicroliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMicrolitersPerSecond(double microliterspersecond)
+        public static VolumeFlow FromMicrolitersPerSecond(double value)
         {
-            return new VolumeFlow(microliterspersecond, VolumeFlowUnit.MicroliterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.MicroliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerDay(double millilitersperday)
+        public static VolumeFlow FromMillilitersPerDay(double value)
         {
-            return new VolumeFlow(millilitersperday, VolumeFlowUnit.MilliliterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerHour(double millilitersperhour)
+        public static VolumeFlow FromMillilitersPerHour(double value)
         {
-            return new VolumeFlow(millilitersperhour, VolumeFlowUnit.MilliliterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerMinute(double millilitersperminute)
+        public static VolumeFlow FromMillilitersPerMinute(double value)
         {
-            return new VolumeFlow(millilitersperminute, VolumeFlowUnit.MilliliterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MilliliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillilitersPerSecond(double milliliterspersecond)
+        public static VolumeFlow FromMillilitersPerSecond(double value)
         {
-            return new VolumeFlow(milliliterspersecond, VolumeFlowUnit.MilliliterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.MilliliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.MillionUsGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromMillionUsGallonsPerDay(double millionusgallonsperday)
+        public static VolumeFlow FromMillionUsGallonsPerDay(double value)
         {
-            return new VolumeFlow(millionusgallonsperday, VolumeFlowUnit.MillionUsGallonPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.MillionUsGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerDay(double nanolitersperday)
+        public static VolumeFlow FromNanolitersPerDay(double value)
         {
-            return new VolumeFlow(nanolitersperday, VolumeFlowUnit.NanoliterPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerHour(double nanolitersperhour)
+        public static VolumeFlow FromNanolitersPerHour(double value)
         {
-            return new VolumeFlow(nanolitersperhour, VolumeFlowUnit.NanoliterPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerMinute(double nanolitersperminute)
+        public static VolumeFlow FromNanolitersPerMinute(double value)
         {
-            return new VolumeFlow(nanolitersperminute, VolumeFlowUnit.NanoliterPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.NanoliterPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromNanolitersPerSecond(double nanoliterspersecond)
+        public static VolumeFlow FromNanolitersPerSecond(double value)
         {
-            return new VolumeFlow(nanoliterspersecond, VolumeFlowUnit.NanoliterPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.NanoliterPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerDay(double oilbarrelsperday)
+        public static VolumeFlow FromOilBarrelsPerDay(double value)
         {
-            return new VolumeFlow(oilbarrelsperday, VolumeFlowUnit.OilBarrelPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerHour(double oilbarrelsperhour)
+        public static VolumeFlow FromOilBarrelsPerHour(double value)
         {
-            return new VolumeFlow(oilbarrelsperhour, VolumeFlowUnit.OilBarrelPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerMinute(double oilbarrelsperminute)
+        public static VolumeFlow FromOilBarrelsPerMinute(double value)
         {
-            return new VolumeFlow(oilbarrelsperminute, VolumeFlowUnit.OilBarrelPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.OilBarrelPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromOilBarrelsPerSecond(double oilbarrelspersecond)
+        public static VolumeFlow FromOilBarrelsPerSecond(double value)
         {
-            return new VolumeFlow(oilbarrelspersecond, VolumeFlowUnit.OilBarrelPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.OilBarrelPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerDay(double ukgallonsperday)
+        public static VolumeFlow FromUkGallonsPerDay(double value)
         {
-            return new VolumeFlow(ukgallonsperday, VolumeFlowUnit.UkGallonPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerHour(double ukgallonsperhour)
+        public static VolumeFlow FromUkGallonsPerHour(double value)
         {
-            return new VolumeFlow(ukgallonsperhour, VolumeFlowUnit.UkGallonPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerMinute(double ukgallonsperminute)
+        public static VolumeFlow FromUkGallonsPerMinute(double value)
         {
-            return new VolumeFlow(ukgallonsperminute, VolumeFlowUnit.UkGallonPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UkGallonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUkGallonsPerSecond(double ukgallonspersecond)
+        public static VolumeFlow FromUkGallonsPerSecond(double value)
         {
-            return new VolumeFlow(ukgallonspersecond, VolumeFlowUnit.UkGallonPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.UkGallonPerSecond);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerDay"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerDay(double usgallonsperday)
+        public static VolumeFlow FromUsGallonsPerDay(double value)
         {
-            return new VolumeFlow(usgallonsperday, VolumeFlowUnit.UsGallonPerDay);
+            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerDay);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerHour"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerHour(double usgallonsperhour)
+        public static VolumeFlow FromUsGallonsPerHour(double value)
         {
-            return new VolumeFlow(usgallonsperhour, VolumeFlowUnit.UsGallonPerHour);
+            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerHour);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerMinute"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerMinute(double usgallonsperminute)
+        public static VolumeFlow FromUsGallonsPerMinute(double value)
         {
-            return new VolumeFlow(usgallonsperminute, VolumeFlowUnit.UsGallonPerMinute);
+            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerMinute);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlow"/> from <see cref="VolumeFlowUnit.UsGallonPerSecond"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlow FromUsGallonsPerSecond(double usgallonspersecond)
+        public static VolumeFlow FromUsGallonsPerSecond(double value)
         {
-            return new VolumeFlow(usgallonspersecond, VolumeFlowUnit.UsGallonPerSecond);
+            return new VolumeFlow(value, VolumeFlowUnit.UsGallonPerSecond);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
index 1c902215c3..e157221bd3 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumeFlowPerArea.g.cs
@@ -229,18 +229,18 @@ public static string GetAbbreviation(VolumeFlowPerAreaUnit unit, IFormatProvider
         ///     Creates a <see cref="VolumeFlowPerArea"/> from <see cref="VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(double cubicfeetperminutepersquarefoot)
+        public static VolumeFlowPerArea FromCubicFeetPerMinutePerSquareFoot(double value)
         {
-            return new VolumeFlowPerArea(cubicfeetperminutepersquarefoot, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
+            return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicFootPerMinutePerSquareFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumeFlowPerArea"/> from <see cref="VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(double cubicmeterspersecondpersquaremeter)
+        public static VolumeFlowPerArea FromCubicMetersPerSecondPerSquareMeter(double value)
         {
-            return new VolumeFlowPerArea(cubicmeterspersecondpersquaremeter, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
+            return new VolumeFlowPerArea(value, VolumeFlowPerAreaUnit.CubicMeterPerSecondPerSquareMeter);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
index dab420b6c8..99c89dcbe3 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumePerLength.g.cs
@@ -285,81 +285,81 @@ public static string GetAbbreviation(VolumePerLengthUnit unit, IFormatProvider?
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicMeterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicMetersPerMeter(double cubicmeterspermeter)
+        public static VolumePerLength FromCubicMetersPerMeter(double value)
         {
-            return new VolumePerLength(cubicmeterspermeter, VolumePerLengthUnit.CubicMeterPerMeter);
+            return new VolumePerLength(value, VolumePerLengthUnit.CubicMeterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicYardPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicYardsPerFoot(double cubicyardsperfoot)
+        public static VolumePerLength FromCubicYardsPerFoot(double value)
         {
-            return new VolumePerLength(cubicyardsperfoot, VolumePerLengthUnit.CubicYardPerFoot);
+            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.CubicYardPerUsSurveyFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double cubicyardsperussurveyfoot)
+        public static VolumePerLength FromCubicYardsPerUsSurveyFoot(double value)
         {
-            return new VolumePerLength(cubicyardsperussurveyfoot, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
+            return new VolumePerLength(value, VolumePerLengthUnit.CubicYardPerUsSurveyFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.ImperialGallonPerMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromImperialGallonsPerMile(double imperialgallonspermile)
+        public static VolumePerLength FromImperialGallonsPerMile(double value)
         {
-            return new VolumePerLength(imperialgallonspermile, VolumePerLengthUnit.ImperialGallonPerMile);
+            return new VolumePerLength(value, VolumePerLengthUnit.ImperialGallonPerMile);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerKilometer"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerKilometer(double litersperkilometer)
+        public static VolumePerLength FromLitersPerKilometer(double value)
         {
-            return new VolumePerLength(litersperkilometer, VolumePerLengthUnit.LiterPerKilometer);
+            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerKilometer);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerMeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerMeter(double literspermeter)
+        public static VolumePerLength FromLitersPerMeter(double value)
         {
-            return new VolumePerLength(literspermeter, VolumePerLengthUnit.LiterPerMeter);
+            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.LiterPerMillimeter"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromLitersPerMillimeter(double literspermillimeter)
+        public static VolumePerLength FromLitersPerMillimeter(double value)
         {
-            return new VolumePerLength(literspermillimeter, VolumePerLengthUnit.LiterPerMillimeter);
+            return new VolumePerLength(value, VolumePerLengthUnit.LiterPerMillimeter);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.OilBarrelPerFoot"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromOilBarrelsPerFoot(double oilbarrelsperfoot)
+        public static VolumePerLength FromOilBarrelsPerFoot(double value)
         {
-            return new VolumePerLength(oilbarrelsperfoot, VolumePerLengthUnit.OilBarrelPerFoot);
+            return new VolumePerLength(value, VolumePerLengthUnit.OilBarrelPerFoot);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumePerLength"/> from <see cref="VolumePerLengthUnit.UsGallonPerMile"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumePerLength FromUsGallonsPerMile(double usgallonspermile)
+        public static VolumePerLength FromUsGallonsPerMile(double value)
         {
-            return new VolumePerLength(usgallonspermile, VolumePerLengthUnit.UsGallonPerMile);
+            return new VolumePerLength(value, VolumePerLengthUnit.UsGallonPerMile);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
index ebd63a3c3b..f78bf80fca 100644
--- a/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/VolumetricHeatCapacity.g.cs
@@ -288,81 +288,81 @@ public static string GetAbbreviation(VolumetricHeatCapacityUnit unit, IFormatPro
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(double btuspercubicfootdegreefahrenheit)
+        public static VolumetricHeatCapacity FromBtusPerCubicFootDegreeFahrenheit(double value)
         {
-            return new VolumetricHeatCapacity(btuspercubicfootdegreefahrenheit, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.BtuPerCubicFootDegreeFahrenheit);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius(double caloriespercubiccentimeterdegreecelsius)
+        public static VolumetricHeatCapacity FromCaloriesPerCubicCentimeterDegreeCelsius(double value)
         {
-            return new VolumetricHeatCapacity(caloriespercubiccentimeterdegreecelsius, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.CaloriePerCubicCentimeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(double joulespercubicmeterdegreecelsius)
+        public static VolumetricHeatCapacity FromJoulesPerCubicMeterDegreeCelsius(double value)
         {
-            return new VolumetricHeatCapacity(joulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(double joulespercubicmeterkelvin)
+        public static VolumetricHeatCapacity FromJoulesPerCubicMeterKelvin(double value)
         {
-            return new VolumetricHeatCapacity(joulespercubicmeterkelvin, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.JoulePerCubicMeterKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCelsius(double kilocaloriespercubiccentimeterdegreecelsius)
+        public static VolumetricHeatCapacity FromKilocaloriesPerCubicCentimeterDegreeCelsius(double value)
         {
-            return new VolumetricHeatCapacity(kilocaloriespercubiccentimeterdegreecelsius, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilocaloriePerCubicCentimeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(double kilojoulespercubicmeterdegreecelsius)
+        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterDegreeCelsius(double value)
         {
-            return new VolumetricHeatCapacity(kilojoulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(double kilojoulespercubicmeterkelvin)
+        public static VolumetricHeatCapacity FromKilojoulesPerCubicMeterKelvin(double value)
         {
-            return new VolumetricHeatCapacity(kilojoulespercubicmeterkelvin, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.KilojoulePerCubicMeterKelvin);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(double megajoulespercubicmeterdegreecelsius)
+        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterDegreeCelsius(double value)
         {
-            return new VolumetricHeatCapacity(megajoulespercubicmeterdegreecelsius, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterDegreeCelsius);
         }
 
         /// <summary>
         ///     Creates a <see cref="VolumetricHeatCapacity"/> from <see cref="VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(double megajoulespercubicmeterkelvin)
+        public static VolumetricHeatCapacity FromMegajoulesPerCubicMeterKelvin(double value)
         {
-            return new VolumetricHeatCapacity(megajoulespercubicmeterkelvin, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
+            return new VolumetricHeatCapacity(value, VolumetricHeatCapacityUnit.MegajoulePerCubicMeterKelvin);
         }
 
         /// <summary>
diff --git a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
index cad17c0388..6a7397b701 100644
--- a/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/WarpingMomentOfInertia.g.cs
@@ -261,54 +261,54 @@ public static string GetAbbreviation(WarpingMomentOfInertiaUnit unit, IFormatPro
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.CentimeterToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromCentimetersToTheSixth(double centimeterstothesixth)
+        public static WarpingMomentOfInertia FromCentimetersToTheSixth(double value)
         {
-            return new WarpingMomentOfInertia(centimeterstothesixth, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
+            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.CentimeterToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.DecimeterToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromDecimetersToTheSixth(double decimeterstothesixth)
+        public static WarpingMomentOfInertia FromDecimetersToTheSixth(double value)
         {
-            return new WarpingMomentOfInertia(decimeterstothesixth, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
+            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.DecimeterToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.FootToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromFeetToTheSixth(double feettothesixth)
+        public static WarpingMomentOfInertia FromFeetToTheSixth(double value)
         {
-            return new WarpingMomentOfInertia(feettothesixth, WarpingMomentOfInertiaUnit.FootToTheSixth);
+            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.FootToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.InchToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromInchesToTheSixth(double inchestothesixth)
+        public static WarpingMomentOfInertia FromInchesToTheSixth(double value)
         {
-            return new WarpingMomentOfInertia(inchestothesixth, WarpingMomentOfInertiaUnit.InchToTheSixth);
+            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.InchToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.MeterToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromMetersToTheSixth(double meterstothesixth)
+        public static WarpingMomentOfInertia FromMetersToTheSixth(double value)
         {
-            return new WarpingMomentOfInertia(meterstothesixth, WarpingMomentOfInertiaUnit.MeterToTheSixth);
+            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MeterToTheSixth);
         }
 
         /// <summary>
         ///     Creates a <see cref="WarpingMomentOfInertia"/> from <see cref="WarpingMomentOfInertiaUnit.MillimeterToTheSixth"/>.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
-        public static WarpingMomentOfInertia FromMillimetersToTheSixth(double millimeterstothesixth)
+        public static WarpingMomentOfInertia FromMillimetersToTheSixth(double value)
         {
-            return new WarpingMomentOfInertia(millimeterstothesixth, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
+            return new WarpingMomentOfInertia(value, WarpingMomentOfInertiaUnit.MillimeterToTheSixth);
         }
 
         /// <summary>

From d387748930760650e7d6c85cdf9595a8c04260c6 Mon Sep 17 00:00:00 2001
From: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>
Date: Fri, 23 Feb 2024 21:57:16 +0100
Subject: [PATCH 10/11] Minor fixes

---
 UnitsNet.Tests/CustomCode/PowerRatioTests.cs | 1 -
 UnitsNet/UnitMath.cs                         | 4 ++--
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/UnitsNet.Tests/CustomCode/PowerRatioTests.cs b/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
index adb1ee96fc..8dab3f359a 100644
--- a/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
+++ b/UnitsNet.Tests/CustomCode/PowerRatioTests.cs
@@ -46,7 +46,6 @@ public void ExpectPowerConvertedCorrectly(double power, double expected)
         }
 
         [Theory]
-        // Note: Attribute arguments cannot be of type decimal.
         [InlineData(-20, 0.01)]
         [InlineData(-10, 0.1)]
         [InlineData(0, 1)]
diff --git a/UnitsNet/UnitMath.cs b/UnitsNet/UnitMath.cs
index a38184033d..472f25c9b7 100644
--- a/UnitsNet/UnitMath.cs
+++ b/UnitsNet/UnitMath.cs
@@ -17,7 +17,7 @@ public static class UnitMath
         /// <returns>A quantity with a value, such that 0 ≤ value ≤ <see cref="F:System.Double.MaxValue" />.</returns>
         public static TQuantity Abs<TQuantity>(this TQuantity value) where TQuantity : IQuantity
         {
-            return value.Value >= 0.0 ? value : (TQuantity) Quantity.From(-value.Value, value.Unit);
+            return value.Value >= 0 ? value : (TQuantity) Quantity.From(-value.Value, value.Unit);
         }
 
         /// <summary>Computes the sum of a sequence of <typeparamref name="TQuantity" /> values.</summary>
@@ -220,7 +220,7 @@ public static TQuantity Clamp<TQuantity>(TQuantity value, TQuantity min, TQuanti
         {
             var minValue = (TQuantity)min.ToUnit(value.Unit);
             var maxValue = (TQuantity)max.ToUnit(value.Unit);
-            
+
             if (minValue.CompareTo(maxValue) > 0)
             {
                 throw new ArgumentException($"min ({min}) cannot be greater than max ({max})", nameof(min));

From 44d31d7dbfbf31ec187c3ea2314ef294874cb86d Mon Sep 17 00:00:00 2001
From: Andreas Gullberg Larsen <andreas.larsen84@gmail.com>
Date: Fri, 23 Feb 2024 22:16:33 +0100
Subject: [PATCH 11/11] Remove test case

---
 .../UnitsNetBaseJsonConverterTest.cs                   | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
index f6f6707788..c438447b5f 100644
--- a/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
+++ b/UnitsNet.Serialization.JsonNet.Tests/UnitsNetBaseJsonConverterTest.cs
@@ -138,16 +138,6 @@ public void UnitsNetBaseJsonConverter_ReadValueUnit_returns_null_when_value_is_a
             Assert.Null(result);
         }
 
-        [Fact]
-        public void UnitsNetBaseJsonConverter_ReadValueUnit_returns_null_when_value_type_is_not_a_string()
-        {
-            var token = new JObject {{"Unit", "PowerUnit.Watt"}, {"Value", 10.2365}, {"ValueType", 123}};
-
-            var result = _sut.Test_ReadDoubleValueUnit(token);
-
-            Assert.Null(result);
-        }
-
         [Fact]
         public void UnitsNetBaseJsonConverter_ReadDoubleValueUnit_works_with_empty_token()
         {