diff --git a/Common/UnitDefinitions/MassConcentration.json b/Common/UnitDefinitions/MassConcentration.json
index fc99caef82..8e1951cd1c 100644
--- a/Common/UnitDefinitions/MassConcentration.json
+++ b/Common/UnitDefinitions/MassConcentration.json
@@ -238,6 +238,30 @@
           "Abbreviations": [ "ppg (U.S.)" ]
         }
       ]
+    },
+	{
+      "SingularName": "OuncePerUSGallon",
+      "PluralName": "OuncesPerUSGallon",
+      "FromUnitToBaseFunc": " x/0.1335264711843",
+      "FromBaseToUnitFunc": "x*0.1335264711843",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "oz/gal (U.S.)" ]
+        }
+      ]
+    },
+	{
+      "SingularName": "OuncePerImperialGallon",
+      "PluralName": "OuncesPerImperialGallon",
+      "FromUnitToBaseFunc": " x/0.1603586720609",
+      "FromBaseToUnitFunc": "x*0.1603586720609",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "oz/gal (imp.)" ]
+        }
+      ]
     },
     {
       "SingularName": "PoundPerImperialGallon",
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassConcentration.g.cs
index d906ae31c6..54416eb19b 100644
--- a/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet.NanoFramework/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -255,6 +255,16 @@ public MassConcentration(double value, MassConcentrationUnit unit)
         /// </summary>
         public double NanogramsPerMilliliter => As(MassConcentrationUnit.NanogramPerMilliliter);
 
+        /// <summary>
+        ///     Get MassConcentration in OuncesPerImperialGallon.
+        /// </summary>
+        public double OuncesPerImperialGallon => As(MassConcentrationUnit.OuncePerImperialGallon);
+
+        /// <summary>
+        ///     Get MassConcentration in OuncesPerUSGallon.
+        /// </summary>
+        public double OuncesPerUSGallon => As(MassConcentrationUnit.OuncePerUSGallon);
+
         /// <summary>
         ///     Get MassConcentration in PicogramsPerDeciliter.
         /// </summary>
@@ -529,6 +539,18 @@ public MassConcentration(double value, MassConcentrationUnit unit)
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
         public static MassConcentration FromNanogramsPerMilliliter(double nanogramspermilliliter) => new MassConcentration(nanogramspermilliliter, MassConcentrationUnit.NanogramPerMilliliter);
 
+        /// <summary>
+        ///     Get MassConcentration from OuncesPerImperialGallon.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static MassConcentration FromOuncesPerImperialGallon(double ouncesperimperialgallon) => new MassConcentration(ouncesperimperialgallon, MassConcentrationUnit.OuncePerImperialGallon);
+
+        /// <summary>
+        ///     Get MassConcentration from OuncesPerUSGallon.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static MassConcentration FromOuncesPerUSGallon(double ouncesperusgallon) => new MassConcentration(ouncesperusgallon, MassConcentrationUnit.OuncePerUSGallon);
+
         /// <summary>
         ///     Get MassConcentration from PicogramsPerDeciliter.
         /// </summary>
@@ -679,6 +701,8 @@ private double GetValueInBaseUnit()
                 case MassConcentrationUnit.NanogramPerLiter: return (_value) * 1e-9d;
                 case MassConcentrationUnit.NanogramPerMicroliter: return (_value/1e-6) * 1e-9d;
                 case MassConcentrationUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d;
+                case MassConcentrationUnit.OuncePerImperialGallon: return  _value/0.1603586720609;
+                case MassConcentrationUnit.OuncePerUSGallon: return  _value/0.1335264711843;
                 case MassConcentrationUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d;
                 case MassConcentrationUnit.PicogramPerLiter: return (_value) * 1e-12d;
                 case MassConcentrationUnit.PicogramPerMicroliter: return (_value/1e-6) * 1e-12d;
@@ -740,6 +764,8 @@ private double GetValueAs(MassConcentrationUnit unit)
                 case MassConcentrationUnit.NanogramPerLiter: return (baseUnitValue) / 1e-9d;
                 case MassConcentrationUnit.NanogramPerMicroliter: return (baseUnitValue*1e-6) / 1e-9d;
                 case MassConcentrationUnit.NanogramPerMilliliter: return (baseUnitValue*1e-3) / 1e-9d;
+                case MassConcentrationUnit.OuncePerImperialGallon: return baseUnitValue*0.1603586720609;
+                case MassConcentrationUnit.OuncePerUSGallon: return baseUnitValue*0.1335264711843;
                 case MassConcentrationUnit.PicogramPerDeciliter: return (baseUnitValue*1e-1) / 1e-12d;
                 case MassConcentrationUnit.PicogramPerLiter: return (baseUnitValue) / 1e-12d;
                 case MassConcentrationUnit.PicogramPerMicroliter: return (baseUnitValue*1e-6) / 1e-12d;
diff --git a/UnitsNet.NanoFramework/GeneratedCode/Units/MassConcentrationUnit.g.cs b/UnitsNet.NanoFramework/GeneratedCode/Units/MassConcentrationUnit.g.cs
index 866db40aa8..75513af502 100644
--- a/UnitsNet.NanoFramework/GeneratedCode/Units/MassConcentrationUnit.g.cs
+++ b/UnitsNet.NanoFramework/GeneratedCode/Units/MassConcentrationUnit.g.cs
@@ -61,6 +61,8 @@ public enum MassConcentrationUnit
         NanogramPerLiter,
         NanogramPerMicroliter,
         NanogramPerMilliliter,
+        OuncePerImperialGallon,
+        OuncePerUSGallon,
         PicogramPerDeciliter,
         PicogramPerLiter,
         PicogramPerMicroliter,
diff --git a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
index 5dcadc5d71..6ea5c05e5f 100644
--- a/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
+++ b/UnitsNet.NumberExtensions.Tests/GeneratedCode/NumberToMassConcentrationExtensionsTest.g.cs
@@ -164,6 +164,14 @@ public void NumberToNanogramsPerMicroliterTest() =>
         public void NumberToNanogramsPerMilliliterTest() =>
             Assert.Equal(MassConcentration.FromNanogramsPerMilliliter(2), 2.NanogramsPerMilliliter());
 
+        [Fact]
+        public void NumberToOuncesPerImperialGallonTest() =>
+            Assert.Equal(MassConcentration.FromOuncesPerImperialGallon(2), 2.OuncesPerImperialGallon());
+
+        [Fact]
+        public void NumberToOuncesPerUSGallonTest() =>
+            Assert.Equal(MassConcentration.FromOuncesPerUSGallon(2), 2.OuncesPerUSGallon());
+
         [Fact]
         public void NumberToPicogramsPerDeciliterTest() =>
             Assert.Equal(MassConcentration.FromPicogramsPerDeciliter(2), 2.PicogramsPerDeciliter());
diff --git a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
index a1c508d59f..e374fe9728 100644
--- a/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
+++ b/UnitsNet.NumberExtensions/GeneratedCode/NumberToMassConcentrationExtensions.g.cs
@@ -168,6 +168,14 @@ public static MassConcentration NanogramsPerMicroliter<T>(this T value) =>
         public static MassConcentration NanogramsPerMilliliter<T>(this T value) =>
             MassConcentration.FromNanogramsPerMilliliter(Convert.ToDouble(value));
 
+        /// <inheritdoc cref="MassConcentration.FromOuncesPerImperialGallon(UnitsNet.QuantityValue)" />
+        public static MassConcentration OuncesPerImperialGallon<T>(this T value) =>
+            MassConcentration.FromOuncesPerImperialGallon(Convert.ToDouble(value));
+
+        /// <inheritdoc cref="MassConcentration.FromOuncesPerUSGallon(UnitsNet.QuantityValue)" />
+        public static MassConcentration OuncesPerUSGallon<T>(this T value) =>
+            MassConcentration.FromOuncesPerUSGallon(Convert.ToDouble(value));
+
         /// <inheritdoc cref="MassConcentration.FromPicogramsPerDeciliter(UnitsNet.QuantityValue)" />
         public static MassConcentration PicogramsPerDeciliter<T>(this T value) =>
             MassConcentration.FromPicogramsPerDeciliter(Convert.ToDouble(value));
diff --git a/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs b/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
index f5d8091b9d..187ac024bc 100644
--- a/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassConcentrationTests.cs
@@ -79,6 +79,10 @@ public class MassConcentrationTests : MassConcentrationTestsBase
         protected override double PoundsPerCubicInchInOneKilogramPerCubicMeter => 3.61272923e-5;
         protected override double PoundsPerUSGallonInOneKilogramPerCubicMeter => 8.3454045e-3;
         protected override double SlugsPerCubicFootInOneKilogramPerCubicMeter => 0.00194032;
+
+        protected override double OuncesPerImperialGallonInOneKilogramPerCubicMeter => 0.1603586720609;
+
+        protected override double OuncesPerUSGallonInOneKilogramPerCubicMeter => 0.1335264711843;
         #endregion
 
         [Theory]
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
index 4aa9c36161..49c606599d 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/MassConcentrationTestsBase.g.cs
@@ -72,6 +72,8 @@ public abstract partial class MassConcentrationTestsBase : QuantityTestsBase
         protected abstract double NanogramsPerLiterInOneKilogramPerCubicMeter { get; }
         protected abstract double NanogramsPerMicroliterInOneKilogramPerCubicMeter { get; }
         protected abstract double NanogramsPerMilliliterInOneKilogramPerCubicMeter { get; }
+        protected abstract double OuncesPerImperialGallonInOneKilogramPerCubicMeter { get; }
+        protected abstract double OuncesPerUSGallonInOneKilogramPerCubicMeter { get; }
         protected abstract double PicogramsPerDeciliterInOneKilogramPerCubicMeter { get; }
         protected abstract double PicogramsPerLiterInOneKilogramPerCubicMeter { get; }
         protected abstract double PicogramsPerMicroliterInOneKilogramPerCubicMeter { get; }
@@ -121,6 +123,8 @@ public abstract partial class MassConcentrationTestsBase : QuantityTestsBase
         protected virtual double NanogramsPerLiterTolerance { get { return 1e-5; } }
         protected virtual double NanogramsPerMicroliterTolerance { get { return 1e-5; } }
         protected virtual double NanogramsPerMilliliterTolerance { get { return 1e-5; } }
+        protected virtual double OuncesPerImperialGallonTolerance { get { return 1e-5; } }
+        protected virtual double OuncesPerUSGallonTolerance { get { return 1e-5; } }
         protected virtual double PicogramsPerDeciliterTolerance { get { return 1e-5; } }
         protected virtual double PicogramsPerLiterTolerance { get { return 1e-5; } }
         protected virtual double PicogramsPerMicroliterTolerance { get { return 1e-5; } }
@@ -242,6 +246,8 @@ public void KilogramPerCubicMeterToMassConcentrationUnits()
             AssertEx.EqualTolerance(NanogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.NanogramsPerLiter, NanogramsPerLiterTolerance);
             AssertEx.EqualTolerance(NanogramsPerMicroliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.NanogramsPerMicroliter, NanogramsPerMicroliterTolerance);
             AssertEx.EqualTolerance(NanogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.NanogramsPerMilliliter, NanogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(OuncesPerImperialGallonInOneKilogramPerCubicMeter, kilogrampercubicmeter.OuncesPerImperialGallon, OuncesPerImperialGallonTolerance);
+            AssertEx.EqualTolerance(OuncesPerUSGallonInOneKilogramPerCubicMeter, kilogrampercubicmeter.OuncesPerUSGallon, OuncesPerUSGallonTolerance);
             AssertEx.EqualTolerance(PicogramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerDeciliter, PicogramsPerDeciliterTolerance);
             AssertEx.EqualTolerance(PicogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerLiter, PicogramsPerLiterTolerance);
             AssertEx.EqualTolerance(PicogramsPerMicroliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.PicogramsPerMicroliter, PicogramsPerMicroliterTolerance);
@@ -399,53 +405,61 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
             AssertEx.EqualTolerance(1, quantity34.NanogramsPerMilliliter, NanogramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.NanogramPerMilliliter, quantity34.Unit);
 
-            var quantity35 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerDeciliter);
-            AssertEx.EqualTolerance(1, quantity35.PicogramsPerDeciliter, PicogramsPerDeciliterTolerance);
-            Assert.Equal(MassConcentrationUnit.PicogramPerDeciliter, quantity35.Unit);
+            var quantity35 = MassConcentration.From(1, MassConcentrationUnit.OuncePerImperialGallon);
+            AssertEx.EqualTolerance(1, quantity35.OuncesPerImperialGallon, OuncesPerImperialGallonTolerance);
+            Assert.Equal(MassConcentrationUnit.OuncePerImperialGallon, quantity35.Unit);
 
-            var quantity36 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerLiter);
-            AssertEx.EqualTolerance(1, quantity36.PicogramsPerLiter, PicogramsPerLiterTolerance);
-            Assert.Equal(MassConcentrationUnit.PicogramPerLiter, quantity36.Unit);
+            var quantity36 = MassConcentration.From(1, MassConcentrationUnit.OuncePerUSGallon);
+            AssertEx.EqualTolerance(1, quantity36.OuncesPerUSGallon, OuncesPerUSGallonTolerance);
+            Assert.Equal(MassConcentrationUnit.OuncePerUSGallon, quantity36.Unit);
 
-            var quantity37 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerMicroliter);
-            AssertEx.EqualTolerance(1, quantity37.PicogramsPerMicroliter, PicogramsPerMicroliterTolerance);
-            Assert.Equal(MassConcentrationUnit.PicogramPerMicroliter, quantity37.Unit);
+            var quantity37 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerDeciliter);
+            AssertEx.EqualTolerance(1, quantity37.PicogramsPerDeciliter, PicogramsPerDeciliterTolerance);
+            Assert.Equal(MassConcentrationUnit.PicogramPerDeciliter, quantity37.Unit);
 
-            var quantity38 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerMilliliter);
-            AssertEx.EqualTolerance(1, quantity38.PicogramsPerMilliliter, PicogramsPerMilliliterTolerance);
-            Assert.Equal(MassConcentrationUnit.PicogramPerMilliliter, quantity38.Unit);
+            var quantity38 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerLiter);
+            AssertEx.EqualTolerance(1, quantity38.PicogramsPerLiter, PicogramsPerLiterTolerance);
+            Assert.Equal(MassConcentrationUnit.PicogramPerLiter, quantity38.Unit);
 
-            var quantity39 = MassConcentration.From(1, MassConcentrationUnit.PoundPerCubicFoot);
-            AssertEx.EqualTolerance(1, quantity39.PoundsPerCubicFoot, PoundsPerCubicFootTolerance);
-            Assert.Equal(MassConcentrationUnit.PoundPerCubicFoot, quantity39.Unit);
+            var quantity39 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerMicroliter);
+            AssertEx.EqualTolerance(1, quantity39.PicogramsPerMicroliter, PicogramsPerMicroliterTolerance);
+            Assert.Equal(MassConcentrationUnit.PicogramPerMicroliter, quantity39.Unit);
 
-            var quantity40 = MassConcentration.From(1, MassConcentrationUnit.PoundPerCubicInch);
-            AssertEx.EqualTolerance(1, quantity40.PoundsPerCubicInch, PoundsPerCubicInchTolerance);
-            Assert.Equal(MassConcentrationUnit.PoundPerCubicInch, quantity40.Unit);
+            var quantity40 = MassConcentration.From(1, MassConcentrationUnit.PicogramPerMilliliter);
+            AssertEx.EqualTolerance(1, quantity40.PicogramsPerMilliliter, PicogramsPerMilliliterTolerance);
+            Assert.Equal(MassConcentrationUnit.PicogramPerMilliliter, quantity40.Unit);
 
-            var quantity41 = MassConcentration.From(1, MassConcentrationUnit.PoundPerImperialGallon);
-            AssertEx.EqualTolerance(1, quantity41.PoundsPerImperialGallon, PoundsPerImperialGallonTolerance);
-            Assert.Equal(MassConcentrationUnit.PoundPerImperialGallon, quantity41.Unit);
+            var quantity41 = MassConcentration.From(1, MassConcentrationUnit.PoundPerCubicFoot);
+            AssertEx.EqualTolerance(1, quantity41.PoundsPerCubicFoot, PoundsPerCubicFootTolerance);
+            Assert.Equal(MassConcentrationUnit.PoundPerCubicFoot, quantity41.Unit);
 
-            var quantity42 = MassConcentration.From(1, MassConcentrationUnit.PoundPerUSGallon);
-            AssertEx.EqualTolerance(1, quantity42.PoundsPerUSGallon, PoundsPerUSGallonTolerance);
-            Assert.Equal(MassConcentrationUnit.PoundPerUSGallon, quantity42.Unit);
+            var quantity42 = MassConcentration.From(1, MassConcentrationUnit.PoundPerCubicInch);
+            AssertEx.EqualTolerance(1, quantity42.PoundsPerCubicInch, PoundsPerCubicInchTolerance);
+            Assert.Equal(MassConcentrationUnit.PoundPerCubicInch, quantity42.Unit);
 
-            var quantity43 = MassConcentration.From(1, MassConcentrationUnit.SlugPerCubicFoot);
-            AssertEx.EqualTolerance(1, quantity43.SlugsPerCubicFoot, SlugsPerCubicFootTolerance);
-            Assert.Equal(MassConcentrationUnit.SlugPerCubicFoot, quantity43.Unit);
+            var quantity43 = MassConcentration.From(1, MassConcentrationUnit.PoundPerImperialGallon);
+            AssertEx.EqualTolerance(1, quantity43.PoundsPerImperialGallon, PoundsPerImperialGallonTolerance);
+            Assert.Equal(MassConcentrationUnit.PoundPerImperialGallon, quantity43.Unit);
 
-            var quantity44 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicCentimeter);
-            AssertEx.EqualTolerance(1, quantity44.TonnesPerCubicCentimeter, TonnesPerCubicCentimeterTolerance);
-            Assert.Equal(MassConcentrationUnit.TonnePerCubicCentimeter, quantity44.Unit);
+            var quantity44 = MassConcentration.From(1, MassConcentrationUnit.PoundPerUSGallon);
+            AssertEx.EqualTolerance(1, quantity44.PoundsPerUSGallon, PoundsPerUSGallonTolerance);
+            Assert.Equal(MassConcentrationUnit.PoundPerUSGallon, quantity44.Unit);
 
-            var quantity45 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicMeter);
-            AssertEx.EqualTolerance(1, quantity45.TonnesPerCubicMeter, TonnesPerCubicMeterTolerance);
-            Assert.Equal(MassConcentrationUnit.TonnePerCubicMeter, quantity45.Unit);
+            var quantity45 = MassConcentration.From(1, MassConcentrationUnit.SlugPerCubicFoot);
+            AssertEx.EqualTolerance(1, quantity45.SlugsPerCubicFoot, SlugsPerCubicFootTolerance);
+            Assert.Equal(MassConcentrationUnit.SlugPerCubicFoot, quantity45.Unit);
 
-            var quantity46 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicMillimeter);
-            AssertEx.EqualTolerance(1, quantity46.TonnesPerCubicMillimeter, TonnesPerCubicMillimeterTolerance);
-            Assert.Equal(MassConcentrationUnit.TonnePerCubicMillimeter, quantity46.Unit);
+            var quantity46 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicCentimeter);
+            AssertEx.EqualTolerance(1, quantity46.TonnesPerCubicCentimeter, TonnesPerCubicCentimeterTolerance);
+            Assert.Equal(MassConcentrationUnit.TonnePerCubicCentimeter, quantity46.Unit);
+
+            var quantity47 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicMeter);
+            AssertEx.EqualTolerance(1, quantity47.TonnesPerCubicMeter, TonnesPerCubicMeterTolerance);
+            Assert.Equal(MassConcentrationUnit.TonnePerCubicMeter, quantity47.Unit);
+
+            var quantity48 = MassConcentration.From(1, MassConcentrationUnit.TonnePerCubicMillimeter);
+            AssertEx.EqualTolerance(1, quantity48.TonnesPerCubicMillimeter, TonnesPerCubicMillimeterTolerance);
+            Assert.Equal(MassConcentrationUnit.TonnePerCubicMillimeter, quantity48.Unit);
 
         }
 
@@ -501,6 +515,8 @@ public void As()
             AssertEx.EqualTolerance(NanogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.NanogramPerLiter), NanogramsPerLiterTolerance);
             AssertEx.EqualTolerance(NanogramsPerMicroliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.NanogramPerMicroliter), NanogramsPerMicroliterTolerance);
             AssertEx.EqualTolerance(NanogramsPerMilliliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.NanogramPerMilliliter), NanogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(OuncesPerImperialGallonInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.OuncePerImperialGallon), OuncesPerImperialGallonTolerance);
+            AssertEx.EqualTolerance(OuncesPerUSGallonInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.OuncePerUSGallon), OuncesPerUSGallonTolerance);
             AssertEx.EqualTolerance(PicogramsPerDeciliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.PicogramPerDeciliter), PicogramsPerDeciliterTolerance);
             AssertEx.EqualTolerance(PicogramsPerLiterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.PicogramPerLiter), PicogramsPerLiterTolerance);
             AssertEx.EqualTolerance(PicogramsPerMicroliterInOneKilogramPerCubicMeter, kilogrampercubicmeter.As(MassConcentrationUnit.PicogramPerMicroliter), PicogramsPerMicroliterTolerance);
@@ -677,6 +693,14 @@ public void ToUnit()
             AssertEx.EqualTolerance(NanogramsPerMilliliterInOneKilogramPerCubicMeter, (double)nanogrampermilliliterQuantity.Value, NanogramsPerMilliliterTolerance);
             Assert.Equal(MassConcentrationUnit.NanogramPerMilliliter, nanogrampermilliliterQuantity.Unit);
 
+            var ounceperimperialgallonQuantity = kilogrampercubicmeter.ToUnit(MassConcentrationUnit.OuncePerImperialGallon);
+            AssertEx.EqualTolerance(OuncesPerImperialGallonInOneKilogramPerCubicMeter, (double)ounceperimperialgallonQuantity.Value, OuncesPerImperialGallonTolerance);
+            Assert.Equal(MassConcentrationUnit.OuncePerImperialGallon, ounceperimperialgallonQuantity.Unit);
+
+            var ounceperusgallonQuantity = kilogrampercubicmeter.ToUnit(MassConcentrationUnit.OuncePerUSGallon);
+            AssertEx.EqualTolerance(OuncesPerUSGallonInOneKilogramPerCubicMeter, (double)ounceperusgallonQuantity.Value, OuncesPerUSGallonTolerance);
+            Assert.Equal(MassConcentrationUnit.OuncePerUSGallon, ounceperusgallonQuantity.Unit);
+
             var picogramperdeciliterQuantity = kilogrampercubicmeter.ToUnit(MassConcentrationUnit.PicogramPerDeciliter);
             AssertEx.EqualTolerance(PicogramsPerDeciliterInOneKilogramPerCubicMeter, (double)picogramperdeciliterQuantity.Value, PicogramsPerDeciliterTolerance);
             Assert.Equal(MassConcentrationUnit.PicogramPerDeciliter, picogramperdeciliterQuantity.Unit);
@@ -772,6 +796,8 @@ public void ConversionRoundTrip()
             AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerLiter(kilogrampercubicmeter.NanogramsPerLiter).KilogramsPerCubicMeter, NanogramsPerLiterTolerance);
             AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerMicroliter(kilogrampercubicmeter.NanogramsPerMicroliter).KilogramsPerCubicMeter, NanogramsPerMicroliterTolerance);
             AssertEx.EqualTolerance(1, MassConcentration.FromNanogramsPerMilliliter(kilogrampercubicmeter.NanogramsPerMilliliter).KilogramsPerCubicMeter, NanogramsPerMilliliterTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration.FromOuncesPerImperialGallon(kilogrampercubicmeter.OuncesPerImperialGallon).KilogramsPerCubicMeter, OuncesPerImperialGallonTolerance);
+            AssertEx.EqualTolerance(1, MassConcentration.FromOuncesPerUSGallon(kilogrampercubicmeter.OuncesPerUSGallon).KilogramsPerCubicMeter, OuncesPerUSGallonTolerance);
             AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerDeciliter(kilogrampercubicmeter.PicogramsPerDeciliter).KilogramsPerCubicMeter, PicogramsPerDeciliterTolerance);
             AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerLiter(kilogrampercubicmeter.PicogramsPerLiter).KilogramsPerCubicMeter, PicogramsPerLiterTolerance);
             AssertEx.EqualTolerance(1, MassConcentration.FromPicogramsPerMicroliter(kilogrampercubicmeter.PicogramsPerMicroliter).KilogramsPerCubicMeter, PicogramsPerMicroliterTolerance);
@@ -977,6 +1003,8 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
                 Assert.Equal("1 ng/L", new MassConcentration(1, MassConcentrationUnit.NanogramPerLiter).ToString());
                 Assert.Equal("1 ng/μL", new MassConcentration(1, MassConcentrationUnit.NanogramPerMicroliter).ToString());
                 Assert.Equal("1 ng/mL", new MassConcentration(1, MassConcentrationUnit.NanogramPerMilliliter).ToString());
+                Assert.Equal("1 oz/gal (imp.)", new MassConcentration(1, MassConcentrationUnit.OuncePerImperialGallon).ToString());
+                Assert.Equal("1 oz/gal (U.S.)", new MassConcentration(1, MassConcentrationUnit.OuncePerUSGallon).ToString());
                 Assert.Equal("1 pg/dL", new MassConcentration(1, MassConcentrationUnit.PicogramPerDeciliter).ToString());
                 Assert.Equal("1 pg/L", new MassConcentration(1, MassConcentrationUnit.PicogramPerLiter).ToString());
                 Assert.Equal("1 pg/μL", new MassConcentration(1, MassConcentrationUnit.PicogramPerMicroliter).ToString());
@@ -1037,6 +1065,8 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             Assert.Equal("1 ng/L", new MassConcentration(1, MassConcentrationUnit.NanogramPerLiter).ToString(swedishCulture));
             Assert.Equal("1 ng/μL", new MassConcentration(1, MassConcentrationUnit.NanogramPerMicroliter).ToString(swedishCulture));
             Assert.Equal("1 ng/mL", new MassConcentration(1, MassConcentrationUnit.NanogramPerMilliliter).ToString(swedishCulture));
+            Assert.Equal("1 oz/gal (imp.)", new MassConcentration(1, MassConcentrationUnit.OuncePerImperialGallon).ToString(swedishCulture));
+            Assert.Equal("1 oz/gal (U.S.)", new MassConcentration(1, MassConcentrationUnit.OuncePerUSGallon).ToString(swedishCulture));
             Assert.Equal("1 pg/dL", new MassConcentration(1, MassConcentrationUnit.PicogramPerDeciliter).ToString(swedishCulture));
             Assert.Equal("1 pg/L", new MassConcentration(1, MassConcentrationUnit.PicogramPerLiter).ToString(swedishCulture));
             Assert.Equal("1 pg/μL", new MassConcentration(1, MassConcentrationUnit.PicogramPerMicroliter).ToString(swedishCulture));
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs
index da65d93666..3dee8e60c8 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -333,6 +333,16 @@ private MassConcentration(double value, MassConcentrationUnit unit)
         /// </summary>
         public double NanogramsPerMilliliter => As(MassConcentrationUnit.NanogramPerMilliliter);
 
+        /// <summary>
+        ///     Get MassConcentration in OuncesPerImperialGallon.
+        /// </summary>
+        public double OuncesPerImperialGallon => As(MassConcentrationUnit.OuncePerImperialGallon);
+
+        /// <summary>
+        ///     Get MassConcentration in OuncesPerUSGallon.
+        /// </summary>
+        public double OuncesPerUSGallon => As(MassConcentrationUnit.OuncePerUSGallon);
+
         /// <summary>
         ///     Get MassConcentration in PicogramsPerDeciliter.
         /// </summary>
@@ -774,6 +784,26 @@ public static MassConcentration FromNanogramsPerMilliliter(double nanogramspermi
             return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter);
         }
         /// <summary>
+        ///     Get MassConcentration from OuncesPerImperialGallon.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static MassConcentration FromOuncesPerImperialGallon(double ouncesperimperialgallon)
+        {
+            double value = (double) ouncesperimperialgallon;
+            return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon);
+        }
+        /// <summary>
+        ///     Get MassConcentration from OuncesPerUSGallon.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static MassConcentration FromOuncesPerUSGallon(double ouncesperusgallon)
+        {
+            double value = (double) ouncesperusgallon;
+            return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon);
+        }
+        /// <summary>
         ///     Get MassConcentration from PicogramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
@@ -1219,6 +1249,8 @@ private double AsBaseUnit()
                 case MassConcentrationUnit.NanogramPerLiter: return (_value) * 1e-9d;
                 case MassConcentrationUnit.NanogramPerMicroliter: return (_value/1e-6) * 1e-9d;
                 case MassConcentrationUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d;
+                case MassConcentrationUnit.OuncePerImperialGallon: return  _value/0.1603586720609;
+                case MassConcentrationUnit.OuncePerUSGallon: return  _value/0.1335264711843;
                 case MassConcentrationUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d;
                 case MassConcentrationUnit.PicogramPerLiter: return (_value) * 1e-12d;
                 case MassConcentrationUnit.PicogramPerMicroliter: return (_value/1e-6) * 1e-12d;
@@ -1280,6 +1312,8 @@ private double AsBaseNumericType(MassConcentrationUnit unit)
                 case MassConcentrationUnit.NanogramPerLiter: return (baseUnitValue) / 1e-9d;
                 case MassConcentrationUnit.NanogramPerMicroliter: return (baseUnitValue*1e-6) / 1e-9d;
                 case MassConcentrationUnit.NanogramPerMilliliter: return (baseUnitValue*1e-3) / 1e-9d;
+                case MassConcentrationUnit.OuncePerImperialGallon: return baseUnitValue*0.1603586720609;
+                case MassConcentrationUnit.OuncePerUSGallon: return baseUnitValue*0.1335264711843;
                 case MassConcentrationUnit.PicogramPerDeciliter: return (baseUnitValue*1e-1) / 1e-12d;
                 case MassConcentrationUnit.PicogramPerLiter: return (baseUnitValue) / 1e-12d;
                 case MassConcentrationUnit.PicogramPerMicroliter: return (baseUnitValue*1e-6) / 1e-12d;
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
index 2da8980d4a..99b9dfc974 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
@@ -860,6 +860,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.NanogramPerLiter, new string[]{"ng/L"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.NanogramPerMicroliter, new string[]{"ng/μL"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.NanogramPerMilliliter, new string[]{"ng/mL"}),
+                ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.OuncePerImperialGallon, new string[]{"oz/gal (imp.)"}),
+                ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.OuncePerUSGallon, new string[]{"oz/gal (U.S.)"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.PicogramPerDeciliter, new string[]{"pg/dL"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.PicogramPerLiter, new string[]{"pg/L"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.PicogramPerMicroliter, new string[]{"pg/μL"}),
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/MassConcentrationUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/MassConcentrationUnit.g.cs
index 866db40aa8..75513af502 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/MassConcentrationUnit.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/MassConcentrationUnit.g.cs
@@ -61,6 +61,8 @@ public enum MassConcentrationUnit
         NanogramPerLiter,
         NanogramPerMicroliter,
         NanogramPerMilliliter,
+        OuncePerImperialGallon,
+        OuncePerUSGallon,
         PicogramPerDeciliter,
         PicogramPerLiter,
         PicogramPerMicroliter,
diff --git a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
index 86fc35175c..d59c9b2676 100644
--- a/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/MassConcentration.g.cs
@@ -90,6 +90,8 @@ static MassConcentration()
                     new UnitInfo<MassConcentrationUnit>(MassConcentrationUnit.NanogramPerLiter, BaseUnits.Undefined),
                     new UnitInfo<MassConcentrationUnit>(MassConcentrationUnit.NanogramPerMicroliter, BaseUnits.Undefined),
                     new UnitInfo<MassConcentrationUnit>(MassConcentrationUnit.NanogramPerMilliliter, BaseUnits.Undefined),
+                    new UnitInfo<MassConcentrationUnit>(MassConcentrationUnit.OuncePerImperialGallon, BaseUnits.Undefined),
+                    new UnitInfo<MassConcentrationUnit>(MassConcentrationUnit.OuncePerUSGallon, BaseUnits.Undefined),
                     new UnitInfo<MassConcentrationUnit>(MassConcentrationUnit.PicogramPerDeciliter, BaseUnits.Undefined),
                     new UnitInfo<MassConcentrationUnit>(MassConcentrationUnit.PicogramPerLiter, BaseUnits.Undefined),
                     new UnitInfo<MassConcentrationUnit>(MassConcentrationUnit.PicogramPerMicroliter, BaseUnits.Undefined),
@@ -392,6 +394,16 @@ public MassConcentration(double value, UnitSystem unitSystem)
         /// </summary>
         public double NanogramsPerMilliliter => As(MassConcentrationUnit.NanogramPerMilliliter);
 
+        /// <summary>
+        ///     Get MassConcentration in OuncesPerImperialGallon.
+        /// </summary>
+        public double OuncesPerImperialGallon => As(MassConcentrationUnit.OuncePerImperialGallon);
+
+        /// <summary>
+        ///     Get MassConcentration in OuncesPerUSGallon.
+        /// </summary>
+        public double OuncesPerUSGallon => As(MassConcentrationUnit.OuncePerUSGallon);
+
         /// <summary>
         ///     Get MassConcentration in PicogramsPerDeciliter.
         /// </summary>
@@ -797,6 +809,24 @@ public static MassConcentration FromNanogramsPerMilliliter(QuantityValue nanogra
             return new MassConcentration(value, MassConcentrationUnit.NanogramPerMilliliter);
         }
         /// <summary>
+        ///     Get MassConcentration from OuncesPerImperialGallon.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static MassConcentration FromOuncesPerImperialGallon(QuantityValue ouncesperimperialgallon)
+        {
+            double value = (double) ouncesperimperialgallon;
+            return new MassConcentration(value, MassConcentrationUnit.OuncePerImperialGallon);
+        }
+        /// <summary>
+        ///     Get MassConcentration from OuncesPerUSGallon.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static MassConcentration FromOuncesPerUSGallon(QuantityValue ouncesperusgallon)
+        {
+            double value = (double) ouncesperusgallon;
+            return new MassConcentration(value, MassConcentrationUnit.OuncePerUSGallon);
+        }
+        /// <summary>
         ///     Get MassConcentration from PicogramsPerDeciliter.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
@@ -1368,6 +1398,8 @@ private double GetValueInBaseUnit()
                 case MassConcentrationUnit.NanogramPerLiter: return (_value) * 1e-9d;
                 case MassConcentrationUnit.NanogramPerMicroliter: return (_value/1e-6) * 1e-9d;
                 case MassConcentrationUnit.NanogramPerMilliliter: return (_value/1e-3) * 1e-9d;
+                case MassConcentrationUnit.OuncePerImperialGallon: return  _value/0.1603586720609;
+                case MassConcentrationUnit.OuncePerUSGallon: return  _value/0.1335264711843;
                 case MassConcentrationUnit.PicogramPerDeciliter: return (_value/1e-1) * 1e-12d;
                 case MassConcentrationUnit.PicogramPerLiter: return (_value) * 1e-12d;
                 case MassConcentrationUnit.PicogramPerMicroliter: return (_value/1e-6) * 1e-12d;
@@ -1440,6 +1472,8 @@ private double GetValueAs(MassConcentrationUnit unit)
                 case MassConcentrationUnit.NanogramPerLiter: return (baseUnitValue) / 1e-9d;
                 case MassConcentrationUnit.NanogramPerMicroliter: return (baseUnitValue*1e-6) / 1e-9d;
                 case MassConcentrationUnit.NanogramPerMilliliter: return (baseUnitValue*1e-3) / 1e-9d;
+                case MassConcentrationUnit.OuncePerImperialGallon: return baseUnitValue*0.1603586720609;
+                case MassConcentrationUnit.OuncePerUSGallon: return baseUnitValue*0.1335264711843;
                 case MassConcentrationUnit.PicogramPerDeciliter: return (baseUnitValue*1e-1) / 1e-12d;
                 case MassConcentrationUnit.PicogramPerLiter: return (baseUnitValue) / 1e-12d;
                 case MassConcentrationUnit.PicogramPerMicroliter: return (baseUnitValue*1e-6) / 1e-12d;
diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
index ca8e554c6e..12e35fd64b 100644
--- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
+++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
@@ -860,6 +860,8 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.NanogramPerLiter, new string[]{"ng/L"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.NanogramPerMicroliter, new string[]{"ng/μL"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.NanogramPerMilliliter, new string[]{"ng/mL"}),
+                ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.OuncePerImperialGallon, new string[]{"oz/gal (imp.)"}),
+                ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.OuncePerUSGallon, new string[]{"oz/gal (U.S.)"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.PicogramPerDeciliter, new string[]{"pg/dL"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.PicogramPerLiter, new string[]{"pg/L"}),
                 ("en-US", typeof(MassConcentrationUnit), (int)MassConcentrationUnit.PicogramPerMicroliter, new string[]{"pg/μL"}),
diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs
index 50992a2ee7..a02cddc3a1 100644
--- a/UnitsNet/GeneratedCode/UnitConverter.g.cs
+++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs
@@ -1242,6 +1242,10 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter)
             unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerMicroliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.NanogramPerMilliliter, q => q.ToUnit(MassConcentrationUnit.NanogramPerMilliliter));
             unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.NanogramPerMilliliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.OuncePerImperialGallon, q => q.ToUnit(MassConcentrationUnit.OuncePerImperialGallon));
+            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.OuncePerImperialGallon, MassConcentration.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.OuncePerUSGallon, q => q.ToUnit(MassConcentrationUnit.OuncePerUSGallon));
+            unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.OuncePerUSGallon, MassConcentration.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PicogramPerDeciliter, q => q.ToUnit(MassConcentrationUnit.PicogramPerDeciliter));
             unitConverter.SetConversionFunction<MassConcentration>(MassConcentrationUnit.PicogramPerDeciliter, MassConcentration.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<MassConcentration>(MassConcentration.BaseUnit, MassConcentrationUnit.PicogramPerLiter, q => q.ToUnit(MassConcentrationUnit.PicogramPerLiter));
diff --git a/UnitsNet/GeneratedCode/Units/MassConcentrationUnit.g.cs b/UnitsNet/GeneratedCode/Units/MassConcentrationUnit.g.cs
index 866db40aa8..75513af502 100644
--- a/UnitsNet/GeneratedCode/Units/MassConcentrationUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/MassConcentrationUnit.g.cs
@@ -61,6 +61,8 @@ public enum MassConcentrationUnit
         NanogramPerLiter,
         NanogramPerMicroliter,
         NanogramPerMilliliter,
+        OuncePerImperialGallon,
+        OuncePerUSGallon,
         PicogramPerDeciliter,
         PicogramPerLiter,
         PicogramPerMicroliter,