diff --git a/Common/UnitRelations.json b/Common/UnitRelations.json
index bded89653c..671f359aea 100644
--- a/Common/UnitRelations.json
+++ b/Common/UnitRelations.json
@@ -10,6 +10,7 @@
   "Area.SquareMeter = KinematicViscosity.SquareMeterPerSecond * Duration.Second -- NoInferredDivision",
   "Area.SquareMeter = Length.Meter * Length.Meter",
   "Area.SquareMeter = Volume.CubicMeter * ReciprocalLength.InverseMeter",
+  "AreaDensity.KilogramPerSquareMeter = Density.KilogramPerCubicMeter * Length.Meter",
   "AreaMomentOfInertia.MeterToTheFourth = Volume.CubicMeter * Length.Meter",
   "double = SpecificEnergy.JoulePerKilogram * BrakeSpecificFuelConsumption.KilogramPerJoule",
   "DynamicViscosity.NewtonSecondPerMeterSquared = Density.KilogramPerCubicMeter * KinematicViscosity.SquareMeterPerSecond",
@@ -27,6 +28,8 @@
   "Force.Newton = ForcePerLength.NewtonPerMeter * Length.Meter",
   "Force.Newton = Mass.Kilogram * Acceleration.MeterPerSecondSquared",
   "Force.Newton = Pressure.Pascal * Area.SquareMeter",
+  "Force.Newton = SpecificWeight.NewtonPerCubicMeter * Volume.CubicMeter",
+  "ForcePerLength.NewtonPerMeter = Acceleration.MeterPerSecondSquared * LinearDensity.KilogramPerMeter",
   "ForcePerLength.NewtonPerMeter = Force.Newton * ReciprocalLength.InverseMeter",
   "ForcePerLength.NewtonPerMeter = Pressure.NewtonPerSquareMeter * Length.Meter",
   "ForcePerLength.NewtonPerMeter = SpecificWeight.NewtonPerCubicMeter * Area.SquareMeter",
@@ -35,6 +38,7 @@
   "Length.Meter = Speed.MeterPerSecond * Duration.Second",
   "Length.Meter = Volume.CubicMeter * ReciprocalArea.InverseSquareMeter",
   "LinearDensity.KilogramPerMeter = Area.SquareMeter * Density.KilogramPerCubicMeter",
+  "LinearDensity.KilogramPerMeter = AreaDensity.KilogramPerSquareMeter * Length.Meter",
   "LuminousFlux.Lumen = Illuminance.Lux * Area.SquareMeter",
   "LuminousIntensity.Candela = Luminance.CandelaPerSquareMeter * Area.SquareMeter",
   "Mass.Kilogram = AmountOfSubstance.Mole * MolarMass.KilogramPerMole",
@@ -61,6 +65,7 @@
   "Power.Watt = Torque.NewtonMeter * RotationalSpeed.RadianPerSecond",
   "Pressure.NewtonPerSquareMeter = Force.Newton * ReciprocalArea.InverseSquareMeter",
   "Pressure.NewtonPerSquareMeter = ForcePerLength.NewtonPerMeter * ReciprocalLength.InverseMeter",
+  "Pressure.Pascal = Acceleration.MeterPerSecondSquared * AreaDensity.KilogramPerSquareMeter",
   "Pressure.Pascal = PressureChangeRate.PascalPerSecond * Duration.Second",
   "Pressure.Pascal = SpecificWeight.NewtonPerCubicMeter * Length.Meter",
   "RadiationEquivalentDose.Sievert = RadiationEquivalentDoseRate.SievertPerHour * Duration.Hour",
diff --git a/UnitsNet.Tests/CustomCode/AccelerationTests.cs b/UnitsNet.Tests/CustomCode/AccelerationTests.cs
index 898b07807b..27baefec3c 100644
--- a/UnitsNet.Tests/CustomCode/AccelerationTests.cs
+++ b/UnitsNet.Tests/CustomCode/AccelerationTests.cs
@@ -35,6 +35,13 @@ public class AccelerationTests : AccelerationTestsBase
 
         protected override double MillistandardGravityInOneMeterPerSecondSquared => 101.9716212977928;
 
+        [Fact]
+        public void AccelerationTimesAreaDensityEqualsPressure()
+        {
+            Pressure pressure = Acceleration.FromMetersPerSecondSquared(10) * AreaDensity.FromKilogramsPerSquareMeter(2);
+            Assert.Equal(Pressure.FromPascals(20), pressure);
+        }
+
         [Fact]
         public void AccelerationTimesDensityEqualsSpecificWeight()
         {
@@ -48,5 +55,12 @@ public void AccelerationTimesDuration()
             Speed speed = Acceleration.FromMetersPerSecondSquared(10) * Duration.FromSeconds(10);
             Assert.Equal(Speed.FromMetersPerSecond(100), speed);
         }
+
+        [Fact]
+        public void AccelerationTimesLinearDensityEqualsForcePerLength()
+        {
+            ForcePerLength forcePerLength = Acceleration.FromMetersPerSecondSquared(10) * LinearDensity.FromKilogramsPerMeter(2);
+            Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), forcePerLength);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/AreaDensityTests.cs b/UnitsNet.Tests/CustomCode/AreaDensityTests.cs
index f9a113d705..6ac3da6862 100644
--- a/UnitsNet.Tests/CustomCode/AreaDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/AreaDensityTests.cs
@@ -34,11 +34,39 @@ public class AreaDensityTests : AreaDensityTestsBase
 
         protected override double MilligramsPerSquareMeterInOneKilogramPerSquareMeter => 1000000;
 
+        [Fact]
+        public void AreaDensityDividedByDensityEqualsLength()
+        {
+            Length length = AreaDensity.FromKilogramsPerSquareMeter(20) / Density.FromKilogramsPerCubicMeter(2);
+            Assert.Equal(Length.FromMeters(10), length);
+        }
+
+        [Fact]
+        public void AreaDensityDividedByLengthEqualsDensity()
+        {
+            Density density = AreaDensity.FromKilogramsPerSquareMeter(20) / Length.FromMeters(2);
+            Assert.Equal(Density.FromKilogramsPerCubicMeter(10), density);
+        }
+
+        [Fact]
+        public void AreaDensityTimesAccelerationEqualsPressure()
+        {
+            Pressure pressure = AreaDensity.FromKilogramsPerSquareMeter(10) * Acceleration.FromMetersPerSecondSquared(2);
+            Assert.Equal(Pressure.FromPascals(20), pressure);
+        }
+
         [Fact]
         public void AreaDensityTimesAreaEqualsMass()
         {
             Mass massOfOneA4Paper = AreaDensity.FromGramsPerSquareMeter(120) * Area.FromSquareCentimeters(625);
             Assert.Equal(7.5, massOfOneA4Paper.Grams);
         }
+
+        [Fact]
+        public void AreaDensityTimesLengthEqualsLinearDensity()
+        {
+            LinearDensity linearDensity = AreaDensity.FromKilogramsPerSquareMeter(10) * Length.FromMeters(2);
+            Assert.Equal(LinearDensity.FromKilogramsPerMeter(20), linearDensity);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/DensityTests.cs b/UnitsNet.Tests/CustomCode/DensityTests.cs
index 178e5043cb..a0b2b581fc 100644
--- a/UnitsNet.Tests/CustomCode/DensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/DensityTests.cs
@@ -161,6 +161,13 @@ public void DensityTimesAreaEqualsLinearDensity()
             Assert.Equal(20, linearDensity.GramsPerCentimeter);
         }
 
+        [Fact]
+        public void DensityTimesLengthEqualsAreaDensity()
+        {
+            AreaDensity areaDensity = Density.FromKilogramsPerCubicMeter(10) * Length.FromMeters(2);
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(20), areaDensity);
+        }
+
         [Fact]
         public static void DensityTimesVolumeConcentrationEqualsMassConcentration()
         {
diff --git a/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs b/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
index 410caf25cb..45b9941b56 100644
--- a/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForcePerLengthTests.cs
@@ -89,5 +89,19 @@ public void ForcePerLengthTimesAreaEqualTorque()
             Torque torque = ForcePerLength.FromNewtonsPerMeter(10) * Area.FromSquareMeters(9);
             Assert.Equal(torque, Torque.FromNewtonMeters(90));
         }
+
+        [Fact]
+        public void ForcePerLengthDividedByAccelerationEqualsLinearDensity()
+        {
+            LinearDensity linearDensity = ForcePerLength.FromNewtonsPerMeter(20) / Acceleration.FromMetersPerSecondSquared(2);
+            Assert.Equal(LinearDensity.FromKilogramsPerMeter(10), linearDensity);
+        }
+
+        [Fact]
+        public void ForcePerLengthDividedByLinearDensityEqualsAcceleration()
+        {
+            Acceleration acceleration = ForcePerLength.FromNewtonsPerMeter(20) / LinearDensity.FromKilogramsPerMeter(2);
+            Assert.Equal(Acceleration.FromMetersPerSecondSquared(10), acceleration);
+        }
     }
 }
diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs
index 30eaf69bc4..4a66384c76 100644
--- a/UnitsNet.Tests/CustomCode/ForceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForceTests.cs
@@ -69,6 +69,20 @@ public void ForceDividedByLengthEqualsForcePerLength()
             Assert.Equal(forcePerLength, ForcePerLength.FromNewtonsPerMeter(4));
         }
 
+        [Fact]
+        public void ForceDividedBySpecificWeightEqualsVolume()
+        {
+            Volume volume = Force.FromNewtons(200) / SpecificWeight.FromNewtonsPerCubicMeter(50);
+            Assert.Equal(Volume.FromCubicMeters(4), volume);
+        }
+
+        [Fact]
+        public void ForceDividedByVolumeEqualsSpecificWeight()
+        {
+            SpecificWeight specificWeight = Force.FromNewtons(200) / Volume.FromCubicMeters(50);
+            Assert.Equal(SpecificWeight.FromNewtonsPerCubicMeter(4), specificWeight);
+        }
+
         [Fact]
         public void MassByAccelerationEqualsForce()
         {
diff --git a/UnitsNet.Tests/CustomCode/LengthTests.cs b/UnitsNet.Tests/CustomCode/LengthTests.cs
index f658ed9d87..47e6d2869f 100644
--- a/UnitsNet.Tests/CustomCode/LengthTests.cs
+++ b/UnitsNet.Tests/CustomCode/LengthTests.cs
@@ -107,6 +107,13 @@ public void ForceTimesLengthEqualsTorque()
             Assert.Equal(torque, Torque.FromNewtonMeters(3));
         }
 
+        [Fact]
+        public void LengthTimesAreaDensityEqualsLinearDensity()
+        {
+            LinearDensity linearDensity = Length.FromMeters(2) * AreaDensity.FromKilogramsPerSquareMeter(10);
+            Assert.Equal(LinearDensity.FromKilogramsPerMeter(20), linearDensity);
+        }
+
         [Fact]
         public void LengthTimesAreaEqualsVolume()
         {
@@ -114,6 +121,13 @@ public void LengthTimesAreaEqualsVolume()
             Assert.Equal(volume, Volume.FromCubicMeters(27));
         }
 
+        [Fact]
+        public void LengthTimesDensityEqualsAreaDensity()
+        {
+            AreaDensity areaDensity = Length.FromMeters(2) * Density.FromKilogramsPerCubicMeter(10);
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(20), areaDensity);
+        }
+
         [Fact]
         public void LengthTimesForceEqualsTorque()
         {
diff --git a/UnitsNet.Tests/CustomCode/LinearDensityTests.cs b/UnitsNet.Tests/CustomCode/LinearDensityTests.cs
index a20e7de897..f5b09664c2 100644
--- a/UnitsNet.Tests/CustomCode/LinearDensityTests.cs
+++ b/UnitsNet.Tests/CustomCode/LinearDensityTests.cs
@@ -60,6 +60,13 @@ public void LinearDensityDividedByAreaEqualsDensity()
             Assert.Equal(5, density.GramsPerCubicCentimeter);
         }
 
+        [Fact]
+        public void LinearDensityDividedByAreaDensityEqualsLength()
+        {
+            Length length = LinearDensity.FromKilogramsPerMeter(20) / AreaDensity.FromKilogramsPerSquareMeter(2);
+            Assert.Equal(Length.FromMeters(10), length);
+        }
+
         [Fact]
         public void LinearDensityDividedByDensityEqualsArea()
         {
@@ -67,6 +74,20 @@ public void LinearDensityDividedByDensityEqualsArea()
             Assert.Equal(5, area.SquareCentimeters);
         }
 
+        [Fact]
+        public void LinearDensityDividedByLengthEqualsAreaDensity()
+        {
+            AreaDensity areaDensity = LinearDensity.FromKilogramsPerMeter(20) / Length.FromMeters(2);
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(10), areaDensity);
+        }
+
+        [Fact]
+        public void LinearDensityTimesAccelerationEqualsForcePerLength()
+        {
+            ForcePerLength forcePerLength = LinearDensity.FromKilogramsPerMeter(10) * Acceleration.FromMetersPerSecondSquared(2);
+            Assert.Equal(ForcePerLength.FromNewtonsPerMeter(20), forcePerLength);
+        }
+
         [Fact]
         public void LinearDensityTimesLengthEqualsMass()
         {
diff --git a/UnitsNet.Tests/CustomCode/PressureTests.cs b/UnitsNet.Tests/CustomCode/PressureTests.cs
index f536bfa00c..74a827cc01 100644
--- a/UnitsNet.Tests/CustomCode/PressureTests.cs
+++ b/UnitsNet.Tests/CustomCode/PressureTests.cs
@@ -211,6 +211,20 @@ public void Gauge_WithVacuumPressureReference_ThrowsArgumentOutOfRangeException(
             Assert.Throws<ArgumentOutOfRangeException>(() => refPressure.Gauge.Atmospheres);
         }
 
+        [Fact]
+        public void PressureDividedByAccelerationEqualsAreaDensity()
+        {
+            var areaDensity = Pressure.FromPascals(20) / Acceleration.FromMetersPerSecondSquared(2);
+            Assert.Equal(AreaDensity.FromKilogramsPerSquareMeter(10), areaDensity);
+        }
+
+        [Fact]
+        public void PressureDividedByAreaDensityEqualsAcceleration()
+        {
+            var acceleration = Pressure.FromPascals(20) / AreaDensity.FromKilogramsPerSquareMeter(2);
+            Assert.Equal(Acceleration.FromMetersPerSecondSquared(10), acceleration);
+        }
+
         [Fact]
         public void PressureDividedByLengthEqualsSpecificWeight()
         {
diff --git a/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs b/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
index f6e56d7ab4..263712248b 100644
--- a/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpecificWeightTests.cs
@@ -48,6 +48,13 @@ public void SpecificWeightTimesLengthEqualsPressure()
             Assert.Equal(Pressure.FromPascals(20), pressure);
         }
 
+        [Fact]
+        public void SpecificWeightTimesVolumeEqualsForce()
+        {
+            Force force = SpecificWeight.FromNewtonsPerCubicMeter(10) * Volume.FromCubicMeters(2);
+            Assert.Equal(Force.FromNewtons(20), force);
+        }
+
         [Fact]
         public void SpecificWeightDividedByDensityEqualsAcceleration()
         {
diff --git a/UnitsNet.Tests/CustomCode/VolumeTests.cs b/UnitsNet.Tests/CustomCode/VolumeTests.cs
index 0df729bde5..c70f2554ff 100644
--- a/UnitsNet.Tests/CustomCode/VolumeTests.cs
+++ b/UnitsNet.Tests/CustomCode/VolumeTests.cs
@@ -134,6 +134,13 @@ public void VolumeTimesDensityEqualsMass()
             Assert.Equal(mass, Mass.FromKilograms(6));
         }
 
+        [Fact]
+        public void VolumeTimesSpecificWeightEqualsForce()
+        {
+            Force force = Volume.FromCubicMeters(2) * SpecificWeight.FromNewtonsPerCubicMeter(3);
+            Assert.Equal(force, Force.FromNewtons(6));
+        }
+
         [Theory]
         [InlineData(20, 2, 10)]
         [InlineData(20, 80, 0.25)]
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
index 83b6c6add3..82217108e5 100644
--- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
@@ -42,7 +42,9 @@ namespace UnitsNet
         IDivisionOperators<Acceleration, Acceleration, double>,
         IDivisionOperators<Acceleration, Jerk, Duration>,
         IMultiplyOperators<Acceleration, Mass, Force>,
+        IMultiplyOperators<Acceleration, LinearDensity, ForcePerLength>,
         IDivisionOperators<Acceleration, Duration, Jerk>,
+        IMultiplyOperators<Acceleration, AreaDensity, Pressure>,
         IMultiplyOperators<Acceleration, Density, SpecificWeight>,
         IMultiplyOperators<Acceleration, Duration, Speed>,
         IComparisonOperators<Acceleration, Acceleration, bool>,
@@ -709,12 +711,24 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Force.FromNewtons(acceleration.MetersPerSecondSquared * mass.Kilograms);
         }
 
+        /// <summary>Get <see cref="ForcePerLength"/> from <see cref="Acceleration"/> * <see cref="LinearDensity"/>.</summary>
+        public static ForcePerLength operator *(Acceleration acceleration, LinearDensity linearDensity)
+        {
+            return ForcePerLength.FromNewtonsPerMeter(acceleration.MetersPerSecondSquared * linearDensity.KilogramsPerMeter);
+        }
+
         /// <summary>Get <see cref="Jerk"/> from <see cref="Acceleration"/> / <see cref="Duration"/>.</summary>
         public static Jerk operator /(Acceleration acceleration, Duration duration)
         {
             return Jerk.FromMetersPerSecondCubed(acceleration.MetersPerSecondSquared / duration.Seconds);
         }
 
+        /// <summary>Get <see cref="Pressure"/> from <see cref="Acceleration"/> * <see cref="AreaDensity"/>.</summary>
+        public static Pressure operator *(Acceleration acceleration, AreaDensity areaDensity)
+        {
+            return Pressure.FromPascals(acceleration.MetersPerSecondSquared * areaDensity.KilogramsPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="SpecificWeight"/> from <see cref="Acceleration"/> * <see cref="Density"/>.</summary>
         public static SpecificWeight operator *(Acceleration acceleration, Density density)
         {
diff --git a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
index 2b662909c4..994d1abcfc 100644
--- a/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/AreaDensity.g.cs
@@ -40,7 +40,11 @@ namespace UnitsNet
         IArithmeticQuantity<AreaDensity, AreaDensityUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<AreaDensity, AreaDensity, double>,
+        IDivisionOperators<AreaDensity, Length, Density>,
+        IDivisionOperators<AreaDensity, Density, Length>,
+        IMultiplyOperators<AreaDensity, Length, LinearDensity>,
         IMultiplyOperators<AreaDensity, Area, Mass>,
+        IMultiplyOperators<AreaDensity, Acceleration, Pressure>,
         IComparisonOperators<AreaDensity, AreaDensity, bool>,
         IParsable<AreaDensity>,
 #endif
@@ -517,12 +521,36 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Density"/> from <see cref="AreaDensity"/> / <see cref="Length"/>.</summary>
+        public static Density operator /(AreaDensity areaDensity, Length length)
+        {
+            return Density.FromKilogramsPerCubicMeter(areaDensity.KilogramsPerSquareMeter / length.Meters);
+        }
+
+        /// <summary>Get <see cref="Length"/> from <see cref="AreaDensity"/> / <see cref="Density"/>.</summary>
+        public static Length operator /(AreaDensity areaDensity, Density density)
+        {
+            return Length.FromMeters(areaDensity.KilogramsPerSquareMeter / density.KilogramsPerCubicMeter);
+        }
+
+        /// <summary>Get <see cref="LinearDensity"/> from <see cref="AreaDensity"/> * <see cref="Length"/>.</summary>
+        public static LinearDensity operator *(AreaDensity areaDensity, Length length)
+        {
+            return LinearDensity.FromKilogramsPerMeter(areaDensity.KilogramsPerSquareMeter * length.Meters);
+        }
+
         /// <summary>Get <see cref="Mass"/> from <see cref="AreaDensity"/> * <see cref="Area"/>.</summary>
         public static Mass operator *(AreaDensity areaDensity, Area area)
         {
             return Mass.FromKilograms(areaDensity.KilogramsPerSquareMeter * area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="Pressure"/> from <see cref="AreaDensity"/> * <see cref="Acceleration"/>.</summary>
+        public static Pressure operator *(AreaDensity areaDensity, Acceleration acceleration)
+        {
+            return Pressure.FromPascals(areaDensity.KilogramsPerSquareMeter * acceleration.MetersPerSecondSquared);
+        }
+
         #endregion
 
         #region Equality / IComparable
diff --git a/UnitsNet/GeneratedCode/Quantities/Density.g.cs b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
index 43aa68b621..7f6a81c42f 100644
--- a/UnitsNet/GeneratedCode/Quantities/Density.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Density.g.cs
@@ -43,6 +43,7 @@ namespace UnitsNet
         IArithmeticQuantity<Density, DensityUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Density, Density, double>,
+        IMultiplyOperators<Density, Length, AreaDensity>,
         IMultiplyOperators<Density, KinematicViscosity, DynamicViscosity>,
         IMultiplyOperators<Density, Area, LinearDensity>,
         IMultiplyOperators<Density, Volume, Mass>,
@@ -1381,6 +1382,12 @@ public SpecificVolume Inverse()
             return SpecificVolume.FromCubicMetersPerKilogram(1 / KilogramsPerCubicMeter);
         }
 
+        /// <summary>Get <see cref="AreaDensity"/> from <see cref="Density"/> * <see cref="Length"/>.</summary>
+        public static AreaDensity operator *(Density density, Length length)
+        {
+            return AreaDensity.FromKilogramsPerSquareMeter(density.KilogramsPerCubicMeter * length.Meters);
+        }
+
         /// <summary>Get <see cref="DynamicViscosity"/> from <see cref="Density"/> * <see cref="KinematicViscosity"/>.</summary>
         public static DynamicViscosity operator *(Density density, KinematicViscosity kinematicViscosity)
         {
diff --git a/UnitsNet/GeneratedCode/Quantities/Force.g.cs b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
index 3e6e0cf3e2..13393e7f9a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Force.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Force.g.cs
@@ -51,7 +51,9 @@ namespace UnitsNet
         IMultiplyOperators<Force, Speed, Power>,
         IMultiplyOperators<Force, ReciprocalArea, Pressure>,
         IDivisionOperators<Force, Area, Pressure>,
+        IDivisionOperators<Force, Volume, SpecificWeight>,
         IMultiplyOperators<Force, Length, Torque>,
+        IDivisionOperators<Force, SpecificWeight, Volume>,
         IComparisonOperators<Force, Force, bool>,
         IParsable<Force>,
 #endif
@@ -786,12 +788,24 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Pressure.FromPascals(force.Newtons / area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="SpecificWeight"/> from <see cref="Force"/> / <see cref="Volume"/>.</summary>
+        public static SpecificWeight operator /(Force force, Volume volume)
+        {
+            return SpecificWeight.FromNewtonsPerCubicMeter(force.Newtons / volume.CubicMeters);
+        }
+
         /// <summary>Get <see cref="Torque"/> from <see cref="Force"/> * <see cref="Length"/>.</summary>
         public static Torque operator *(Force force, Length length)
         {
             return Torque.FromNewtonMeters(force.Newtons * length.Meters);
         }
 
+        /// <summary>Get <see cref="Volume"/> from <see cref="Force"/> / <see cref="SpecificWeight"/>.</summary>
+        public static Volume operator /(Force force, SpecificWeight specificWeight)
+        {
+            return Volume.FromCubicMeters(force.Newtons / specificWeight.NewtonsPerCubicMeter);
+        }
+
         #endregion
 
         #region Equality / IComparable
diff --git a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
index af311d6eb2..6da0d44450 100644
--- a/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/ForcePerLength.g.cs
@@ -40,10 +40,12 @@ namespace UnitsNet
         IArithmeticQuantity<ForcePerLength, ForcePerLengthUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<ForcePerLength, ForcePerLength, double>,
+        IDivisionOperators<ForcePerLength, LinearDensity, Acceleration>,
         IDivisionOperators<ForcePerLength, SpecificWeight, Area>,
         IMultiplyOperators<ForcePerLength, Length, Force>,
         IDivisionOperators<ForcePerLength, ReciprocalLength, Force>,
         IDivisionOperators<ForcePerLength, Pressure, Length>,
+        IDivisionOperators<ForcePerLength, Acceleration, LinearDensity>,
         IMultiplyOperators<ForcePerLength, ReciprocalLength, Pressure>,
         IDivisionOperators<ForcePerLength, Length, Pressure>,
         IDivisionOperators<ForcePerLength, Force, ReciprocalLength>,
@@ -1085,6 +1087,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Acceleration"/> from <see cref="ForcePerLength"/> / <see cref="LinearDensity"/>.</summary>
+        public static Acceleration operator /(ForcePerLength forcePerLength, LinearDensity linearDensity)
+        {
+            return Acceleration.FromMetersPerSecondSquared(forcePerLength.NewtonsPerMeter / linearDensity.KilogramsPerMeter);
+        }
+
         /// <summary>Get <see cref="Area"/> from <see cref="ForcePerLength"/> / <see cref="SpecificWeight"/>.</summary>
         public static Area operator /(ForcePerLength forcePerLength, SpecificWeight specificWeight)
         {
@@ -1109,6 +1117,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Length.FromMeters(forcePerLength.NewtonsPerMeter / pressure.NewtonsPerSquareMeter);
         }
 
+        /// <summary>Get <see cref="LinearDensity"/> from <see cref="ForcePerLength"/> / <see cref="Acceleration"/>.</summary>
+        public static LinearDensity operator /(ForcePerLength forcePerLength, Acceleration acceleration)
+        {
+            return LinearDensity.FromKilogramsPerMeter(forcePerLength.NewtonsPerMeter / acceleration.MetersPerSecondSquared);
+        }
+
         /// <summary>Get <see cref="Pressure"/> from <see cref="ForcePerLength"/> * <see cref="ReciprocalLength"/>.</summary>
         public static Pressure operator *(ForcePerLength forcePerLength, ReciprocalLength reciprocalLength)
         {
diff --git a/UnitsNet/GeneratedCode/Quantities/Length.g.cs b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
index 9974ed8191..022f4e5ebe 100644
--- a/UnitsNet/GeneratedCode/Quantities/Length.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Length.g.cs
@@ -42,11 +42,13 @@ namespace UnitsNet
         IDivisionOperators<Length, Length, double>,
         IMultiplyOperators<Length, Length, Area>,
         IDivisionOperators<Length, ReciprocalLength, Area>,
+        IMultiplyOperators<Length, Density, AreaDensity>,
         IMultiplyOperators<Length, Volume, AreaMomentOfInertia>,
         IDivisionOperators<Length, Speed, Duration>,
         IMultiplyOperators<Length, ForcePerLength, Force>,
         IMultiplyOperators<Length, Pressure, ForcePerLength>,
         IMultiplyOperators<Length, Speed, KinematicViscosity>,
+        IMultiplyOperators<Length, AreaDensity, LinearDensity>,
         IMultiplyOperators<Length, LinearDensity, Mass>,
         IMultiplyOperators<Length, SpecificWeight, Pressure>,
         IDivisionOperators<Length, Volume, ReciprocalArea>,
@@ -1177,6 +1179,12 @@ public ReciprocalLength Inverse()
             return Area.FromSquareMeters(length.Meters / reciprocalLength.InverseMeters);
         }
 
+        /// <summary>Get <see cref="AreaDensity"/> from <see cref="Length"/> * <see cref="Density"/>.</summary>
+        public static AreaDensity operator *(Length length, Density density)
+        {
+            return AreaDensity.FromKilogramsPerSquareMeter(length.Meters * density.KilogramsPerCubicMeter);
+        }
+
         /// <summary>Get <see cref="AreaMomentOfInertia"/> from <see cref="Length"/> * <see cref="Volume"/>.</summary>
         public static AreaMomentOfInertia operator *(Length length, Volume volume)
         {
@@ -1207,6 +1215,12 @@ public ReciprocalLength Inverse()
             return KinematicViscosity.FromSquareMetersPerSecond(length.Meters * speed.MetersPerSecond);
         }
 
+        /// <summary>Get <see cref="LinearDensity"/> from <see cref="Length"/> * <see cref="AreaDensity"/>.</summary>
+        public static LinearDensity operator *(Length length, AreaDensity areaDensity)
+        {
+            return LinearDensity.FromKilogramsPerMeter(length.Meters * areaDensity.KilogramsPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="Mass"/> from <see cref="Length"/> * <see cref="LinearDensity"/>.</summary>
         public static Mass operator *(Length length, LinearDensity linearDensity)
         {
diff --git a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
index a6d4bcc7e7..8b22101362 100644
--- a/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/LinearDensity.g.cs
@@ -44,7 +44,10 @@ namespace UnitsNet
 #if NET7_0_OR_GREATER
         IDivisionOperators<LinearDensity, LinearDensity, double>,
         IDivisionOperators<LinearDensity, Density, Area>,
+        IDivisionOperators<LinearDensity, Length, AreaDensity>,
         IDivisionOperators<LinearDensity, Area, Density>,
+        IMultiplyOperators<LinearDensity, Acceleration, ForcePerLength>,
+        IDivisionOperators<LinearDensity, AreaDensity, Length>,
         IMultiplyOperators<LinearDensity, Length, Mass>,
         IComparisonOperators<LinearDensity, LinearDensity, bool>,
         IParsable<LinearDensity>,
@@ -768,12 +771,30 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Area.FromSquareMeters(linearDensity.KilogramsPerMeter / density.KilogramsPerCubicMeter);
         }
 
+        /// <summary>Get <see cref="AreaDensity"/> from <see cref="LinearDensity"/> / <see cref="Length"/>.</summary>
+        public static AreaDensity operator /(LinearDensity linearDensity, Length length)
+        {
+            return AreaDensity.FromKilogramsPerSquareMeter(linearDensity.KilogramsPerMeter / length.Meters);
+        }
+
         /// <summary>Get <see cref="Density"/> from <see cref="LinearDensity"/> / <see cref="Area"/>.</summary>
         public static Density operator /(LinearDensity linearDensity, Area area)
         {
             return Density.FromKilogramsPerCubicMeter(linearDensity.KilogramsPerMeter / area.SquareMeters);
         }
 
+        /// <summary>Get <see cref="ForcePerLength"/> from <see cref="LinearDensity"/> * <see cref="Acceleration"/>.</summary>
+        public static ForcePerLength operator *(LinearDensity linearDensity, Acceleration acceleration)
+        {
+            return ForcePerLength.FromNewtonsPerMeter(linearDensity.KilogramsPerMeter * acceleration.MetersPerSecondSquared);
+        }
+
+        /// <summary>Get <see cref="Length"/> from <see cref="LinearDensity"/> / <see cref="AreaDensity"/>.</summary>
+        public static Length operator /(LinearDensity linearDensity, AreaDensity areaDensity)
+        {
+            return Length.FromMeters(linearDensity.KilogramsPerMeter / areaDensity.KilogramsPerSquareMeter);
+        }
+
         /// <summary>Get <see cref="Mass"/> from <see cref="LinearDensity"/> * <see cref="Length"/>.</summary>
         public static Mass operator *(LinearDensity linearDensity, Length length)
         {
diff --git a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
index 2a91befa59..7ff1044523 100644
--- a/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Pressure.g.cs
@@ -40,6 +40,8 @@ namespace UnitsNet
         IArithmeticQuantity<Pressure, PressureUnit>,
 #if NET7_0_OR_GREATER
         IDivisionOperators<Pressure, Pressure, double>,
+        IDivisionOperators<Pressure, AreaDensity, Acceleration>,
+        IDivisionOperators<Pressure, Acceleration, AreaDensity>,
         IDivisionOperators<Pressure, PressureChangeRate, Duration>,
         IDivisionOperators<Pressure, ReciprocalArea, Force>,
         IMultiplyOperators<Pressure, Area, Force>,
@@ -1246,6 +1248,18 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
 
         #region Relational Operators
 
+        /// <summary>Get <see cref="Acceleration"/> from <see cref="Pressure"/> / <see cref="AreaDensity"/>.</summary>
+        public static Acceleration operator /(Pressure pressure, AreaDensity areaDensity)
+        {
+            return Acceleration.FromMetersPerSecondSquared(pressure.Pascals / areaDensity.KilogramsPerSquareMeter);
+        }
+
+        /// <summary>Get <see cref="AreaDensity"/> from <see cref="Pressure"/> / <see cref="Acceleration"/>.</summary>
+        public static AreaDensity operator /(Pressure pressure, Acceleration acceleration)
+        {
+            return AreaDensity.FromKilogramsPerSquareMeter(pressure.Pascals / acceleration.MetersPerSecondSquared);
+        }
+
         /// <summary>Get <see cref="Duration"/> from <see cref="Pressure"/> / <see cref="PressureChangeRate"/>.</summary>
         public static Duration operator /(Pressure pressure, PressureChangeRate pressureChangeRate)
         {
diff --git a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
index 5903a099c5..e3ffe91099 100644
--- a/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/SpecificWeight.g.cs
@@ -45,6 +45,7 @@ namespace UnitsNet
         IDivisionOperators<SpecificWeight, SpecificWeight, double>,
         IDivisionOperators<SpecificWeight, Density, Acceleration>,
         IDivisionOperators<SpecificWeight, Acceleration, Density>,
+        IMultiplyOperators<SpecificWeight, Volume, Force>,
         IMultiplyOperators<SpecificWeight, Area, ForcePerLength>,
         IMultiplyOperators<SpecificWeight, Length, Pressure>,
         IComparisonOperators<SpecificWeight, SpecificWeight, bool>,
@@ -759,6 +760,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Density.FromKilogramsPerCubicMeter(specificWeight.NewtonsPerCubicMeter / acceleration.MetersPerSecondSquared);
         }
 
+        /// <summary>Get <see cref="Force"/> from <see cref="SpecificWeight"/> * <see cref="Volume"/>.</summary>
+        public static Force operator *(SpecificWeight specificWeight, Volume volume)
+        {
+            return Force.FromNewtons(specificWeight.NewtonsPerCubicMeter * volume.CubicMeters);
+        }
+
         /// <summary>Get <see cref="ForcePerLength"/> from <see cref="SpecificWeight"/> * <see cref="Area"/>.</summary>
         public static ForcePerLength operator *(SpecificWeight specificWeight, Area area)
         {
diff --git a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
index 223437b961..d00566701a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Volume.g.cs
@@ -46,6 +46,7 @@ namespace UnitsNet
         IMultiplyOperators<Volume, Length, AreaMomentOfInertia>,
         IDivisionOperators<Volume, VolumeFlow, Duration>,
         IMultiplyOperators<Volume, EnergyDensity, Energy>,
+        IMultiplyOperators<Volume, SpecificWeight, Force>,
         IMultiplyOperators<Volume, ReciprocalArea, Length>,
         IDivisionOperators<Volume, Area, Length>,
         IMultiplyOperators<Volume, Density, Mass>,
@@ -1397,6 +1398,12 @@ public static bool TryParseUnit([NotNullWhen(true)]string? str, IFormatProvider?
             return Energy.FromJoules(volume.CubicMeters * energyDensity.JoulesPerCubicMeter);
         }
 
+        /// <summary>Get <see cref="Force"/> from <see cref="Volume"/> * <see cref="SpecificWeight"/>.</summary>
+        public static Force operator *(Volume volume, SpecificWeight specificWeight)
+        {
+            return Force.FromNewtons(volume.CubicMeters * specificWeight.NewtonsPerCubicMeter);
+        }
+
         /// <summary>Get <see cref="Length"/> from <see cref="Volume"/> * <see cref="ReciprocalArea"/>.</summary>
         public static Length operator *(Volume volume, ReciprocalArea reciprocalArea)
         {