diff --git a/UnitsNet.Tests/CustomCode/AccelerationTests.cs b/UnitsNet.Tests/CustomCode/AccelerationTests.cs
index 459b8db734..0f1826b338 100644
--- a/UnitsNet.Tests/CustomCode/AccelerationTests.cs
+++ b/UnitsNet.Tests/CustomCode/AccelerationTests.cs
@@ -23,19 +23,19 @@ namespace UnitsNet.Tests.CustomCode
 {
     public class AccelerationTests : AccelerationTestsBase
     {
-        protected override double KilometerPerSecondSquaredInOneMeterPerSecondSquared => 1E-3;
+        protected override double KilometersPerSecondSquaredInOneMeterPerSecondSquared => 1E-3;
 
-        protected override double MeterPerSecondSquaredInOneMeterPerSecondSquared => 1;
+        protected override double MetersPerSecondSquaredInOneMeterPerSecondSquared => 1;
 
-        protected override double DecimeterPerSecondSquaredInOneMeterPerSecondSquared => 1E1;
+        protected override double DecimetersPerSecondSquaredInOneMeterPerSecondSquared => 1E1;
 
-        protected override double CentimeterPerSecondSquaredInOneMeterPerSecondSquared => 1E2;
+        protected override double CentimetersPerSecondSquaredInOneMeterPerSecondSquared => 1E2;
 
-        protected override double MillimeterPerSecondSquaredInOneMeterPerSecondSquared => 1E3;
+        protected override double MillimetersPerSecondSquaredInOneMeterPerSecondSquared => 1E3;
 
-        protected override double MicrometerPerSecondSquaredInOneMeterPerSecondSquared => 1E6;
+        protected override double MicrometersPerSecondSquaredInOneMeterPerSecondSquared => 1E6;
 
-        protected override double NanometerPerSecondSquaredInOneMeterPerSecondSquared => 1E9;
+        protected override double NanometersPerSecondSquaredInOneMeterPerSecondSquared => 1E9;
 
         protected override double StandardGravityInOneMeterPerSecondSquared => 0.1019727;
 
diff --git a/UnitsNet.Tests/CustomCode/ForceTests.cs b/UnitsNet.Tests/CustomCode/ForceTests.cs
index 67bea8715b..795a569b53 100644
--- a/UnitsNet.Tests/CustomCode/ForceTests.cs
+++ b/UnitsNet.Tests/CustomCode/ForceTests.cs
@@ -68,13 +68,13 @@ public void PressureByAreaEqualsForceUsingLength2D()
         public void ForceDividedByMassEqualsAcceleration()
         {
             Acceleration acceleration = Force.FromNewtons(27)/Mass.FromKilograms(9);
-            Assert.Equal(acceleration, Acceleration.FromMeterPerSecondSquared(3));
+            Assert.Equal(acceleration, Acceleration.FromMetersPerSecondSquared(3));
         }
     
         [Fact]
         public void ForceDividedByAccelerationEqualsMass()
         {
-          Mass acceleration = Force.FromNewtons(200)/Acceleration.FromMeterPerSecondSquared(50);
+          Mass acceleration = Force.FromNewtons(200)/Acceleration.FromMetersPerSecondSquared(50);
           Assert.Equal(acceleration, Mass.FromKilograms(4));
         }
 
@@ -94,7 +94,7 @@ public void MassByAccelerationEqualsForceUsingDouble()
         [Fact]
         public void MassByAccelerationEqualsForce()
         {
-            Force force = Force.FromMassByAcceleration(Mass.FromKilograms(85), Acceleration.FromMeterPerSecondSquared(-4));
+            Force force = Force.FromMassByAcceleration(Mass.FromKilograms(85), Acceleration.FromMetersPerSecondSquared(-4));
             Assert.Equal(force, Force.FromNewtons(-340));
         }
 
@@ -112,4 +112,4 @@ public void SpeedTimesForceEqualsPower()
             Assert.Equal(power, Power.FromWatts(270));
         }
     }
-}
\ No newline at end of file
+}
diff --git a/UnitsNet.Tests/CustomCode/MassTests.cs b/UnitsNet.Tests/CustomCode/MassTests.cs
index e6e89065d7..a4e16a0bbe 100644
--- a/UnitsNet.Tests/CustomCode/MassTests.cs
+++ b/UnitsNet.Tests/CustomCode/MassTests.cs
@@ -73,7 +73,7 @@ public class MassTests : MassTestsBase
         [Fact]
         public void AccelerationTimesMassEqualsForce()
         {
-            Force force = Acceleration.FromMeterPerSecondSquared(3)*Mass.FromKilograms(18);
+            Force force = Acceleration.FromMetersPerSecondSquared(3)*Mass.FromKilograms(18);
             Assert.Equal(force, Force.FromNewtons(54));
         }
 
@@ -101,7 +101,7 @@ public void MassDividedByVolumeEqualsDensity()
         [Fact]
         public void MassTimesAccelerationEqualsForce()
         {
-            Force force = Mass.FromKilograms(18)*Acceleration.FromMeterPerSecondSquared(3);
+            Force force = Mass.FromKilograms(18)*Acceleration.FromMetersPerSecondSquared(3);
             Assert.Equal(force, Force.FromNewtons(54));
         }
     }
diff --git a/UnitsNet.Tests/CustomCode/SpeedTests.cs b/UnitsNet.Tests/CustomCode/SpeedTests.cs
index ed98670905..b297f206cf 100644
--- a/UnitsNet.Tests/CustomCode/SpeedTests.cs
+++ b/UnitsNet.Tests/CustomCode/SpeedTests.cs
@@ -115,14 +115,14 @@ public void LengthDividedByTimeSpanEqualsSpeed()
         public void SpeedDividedByDurationEqualsAcceleration()
         {
             Acceleration acceleration = Speed.FromMetersPerSecond(20)/Duration.FromSeconds(2);
-            Assert.Equal(acceleration, Acceleration.FromMeterPerSecondSquared(10));
+            Assert.Equal(acceleration, Acceleration.FromMetersPerSecondSquared(10));
         }
 
         [Fact]
         public void SpeedDividedByTimeSpanEqualsAcceleration()
         {
             Acceleration acceleration = Speed.FromMetersPerSecond(20)/TimeSpan.FromSeconds(2);
-            Assert.Equal(acceleration, Acceleration.FromMeterPerSecondSquared(10));
+            Assert.Equal(acceleration, Acceleration.FromMetersPerSecondSquared(10));
         }
 
         [Fact]
diff --git a/UnitsNet.Tests/DecimalOverloadTests.cs b/UnitsNet.Tests/DecimalOverloadTests.cs
index 286813fcf8..f19e131a14 100644
--- a/UnitsNet.Tests/DecimalOverloadTests.cs
+++ b/UnitsNet.Tests/DecimalOverloadTests.cs
@@ -31,24 +31,24 @@ public class DecimalOverloadTests
         public static void CreatingQuantityWithDoubleBackingFieldFromDecimalReturnsCorrectValue()
         {
             decimal oneMeterPerSecondSquared = 1m;
-            Acceleration acceleration = Acceleration.FromMeterPerSecondSquared(oneMeterPerSecondSquared);
-            Assert.Equal(1.0, acceleration.MeterPerSecondSquared);
+            Acceleration acceleration = Acceleration.FromMetersPerSecondSquared(oneMeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableDecimalReturnsCorrectValue()
         {
             decimal? oneMeterPerSecondSquared = 1m;
-            Acceleration? acceleration = Acceleration.FromMeterPerSecondSquared(oneMeterPerSecondSquared);
+            Acceleration? acceleration = Acceleration.FromMetersPerSecondSquared(oneMeterPerSecondSquared);
             Assert.NotNull(acceleration);
-            Assert.Equal(1.0, acceleration.Value.MeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.Value.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableDecimalReturnsNullWhenGivenNull()
         {
             decimal? nullDecimal = null;
-            Acceleration? acceleration = Acceleration.FromMeterPerSecondSquared(nullDecimal);
+            Acceleration? acceleration = Acceleration.FromMetersPerSecondSquared(nullDecimal);
             Assert.Null(acceleration);
         }
 
@@ -56,24 +56,24 @@ public static void CreatingQuantityWithDoubleBackingFieldFromNullableDecimalRetu
         public static void CreatingQuantityWithDoubleBackingFieldFromDecimalWithExtensionMethodReturnsCorrectValue()
         {
             decimal oneMeterPerSecondSquared = 1m;
-            Acceleration acceleration = oneMeterPerSecondSquared.MeterPerSecondSquared();
-            Assert.Equal(1.0, acceleration.MeterPerSecondSquared);
+            Acceleration acceleration = oneMeterPerSecondSquared.MetersPerSecondSquared();
+            Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableDecimalWithExtensionMethodReturnsCorrectValue()
         {
             decimal? oneMeterPerSecondSquared = 1m;
-            Acceleration? acceleration = oneMeterPerSecondSquared.MeterPerSecondSquared();
+            Acceleration? acceleration = oneMeterPerSecondSquared.MetersPerSecondSquared();
             Assert.NotNull(acceleration);
-            Assert.Equal(1.0, acceleration.Value.MeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.Value.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableDecimalWithExtensionMethodReturnsNullWhenGivenNull()
         {
             decimal? nullDecimal = null;
-            Acceleration? acceleration = nullDecimal.MeterPerSecondSquared();
+            Acceleration? acceleration = nullDecimal.MetersPerSecondSquared();
             Assert.Null(acceleration);
         }
 
diff --git a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs
index c420fd59ce..f7b4a7548d 100644
--- a/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/AccelerationTestsBase.g.cs
@@ -52,145 +52,145 @@ namespace UnitsNet.Tests
 // ReSharper disable once PartialTypeWithSinglePart
     public abstract partial class AccelerationTestsBase
     {
-        protected abstract double CentimeterPerSecondSquaredInOneMeterPerSecondSquared { get; }
-        protected abstract double DecimeterPerSecondSquaredInOneMeterPerSecondSquared { get; }
+        protected abstract double CentimetersPerSecondSquaredInOneMeterPerSecondSquared { get; }
+        protected abstract double DecimetersPerSecondSquaredInOneMeterPerSecondSquared { get; }
         protected abstract double FeetPerSecondSquaredInOneMeterPerSecondSquared { get; }
         protected abstract double InchesPerSecondSquaredInOneMeterPerSecondSquared { get; }
-        protected abstract double KilometerPerSecondSquaredInOneMeterPerSecondSquared { get; }
+        protected abstract double KilometersPerSecondSquaredInOneMeterPerSecondSquared { get; }
         protected abstract double KnotsPerHourInOneMeterPerSecondSquared { get; }
         protected abstract double KnotsPerMinuteInOneMeterPerSecondSquared { get; }
         protected abstract double KnotsPerSecondInOneMeterPerSecondSquared { get; }
-        protected abstract double MeterPerSecondSquaredInOneMeterPerSecondSquared { get; }
-        protected abstract double MicrometerPerSecondSquaredInOneMeterPerSecondSquared { get; }
-        protected abstract double MillimeterPerSecondSquaredInOneMeterPerSecondSquared { get; }
-        protected abstract double NanometerPerSecondSquaredInOneMeterPerSecondSquared { get; }
+        protected abstract double MetersPerSecondSquaredInOneMeterPerSecondSquared { get; }
+        protected abstract double MicrometersPerSecondSquaredInOneMeterPerSecondSquared { get; }
+        protected abstract double MillimetersPerSecondSquaredInOneMeterPerSecondSquared { get; }
+        protected abstract double NanometersPerSecondSquaredInOneMeterPerSecondSquared { get; }
         protected abstract double StandardGravityInOneMeterPerSecondSquared { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
-        protected virtual double CentimeterPerSecondSquaredTolerance { get { return 1e-5; } }
-        protected virtual double DecimeterPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double CentimetersPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double DecimetersPerSecondSquaredTolerance { get { return 1e-5; } }
         protected virtual double FeetPerSecondSquaredTolerance { get { return 1e-5; } }
         protected virtual double InchesPerSecondSquaredTolerance { get { return 1e-5; } }
-        protected virtual double KilometerPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double KilometersPerSecondSquaredTolerance { get { return 1e-5; } }
         protected virtual double KnotsPerHourTolerance { get { return 1e-5; } }
         protected virtual double KnotsPerMinuteTolerance { get { return 1e-5; } }
         protected virtual double KnotsPerSecondTolerance { get { return 1e-5; } }
-        protected virtual double MeterPerSecondSquaredTolerance { get { return 1e-5; } }
-        protected virtual double MicrometerPerSecondSquaredTolerance { get { return 1e-5; } }
-        protected virtual double MillimeterPerSecondSquaredTolerance { get { return 1e-5; } }
-        protected virtual double NanometerPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double MetersPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double MicrometersPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double MillimetersPerSecondSquaredTolerance { get { return 1e-5; } }
+        protected virtual double NanometersPerSecondSquaredTolerance { get { return 1e-5; } }
         protected virtual double StandardGravityTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Fact]
         public void MeterPerSecondSquaredToAccelerationUnits()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1);
-            AssertEx.EqualTolerance(CentimeterPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.CentimeterPerSecondSquared, CentimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(DecimeterPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.DecimeterPerSecondSquared, DecimeterPerSecondSquaredTolerance);
+            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            AssertEx.EqualTolerance(CentimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.CentimetersPerSecondSquared, CentimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(DecimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.DecimetersPerSecondSquared, DecimetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(FeetPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.FeetPerSecondSquared, FeetPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(InchesPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.InchesPerSecondSquared, InchesPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(KilometerPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.KilometerPerSecondSquared, KilometerPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(KilometersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.KilometersPerSecondSquared, KilometersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(KnotsPerHourInOneMeterPerSecondSquared, meterpersecondsquared.KnotsPerHour, KnotsPerHourTolerance);
             AssertEx.EqualTolerance(KnotsPerMinuteInOneMeterPerSecondSquared, meterpersecondsquared.KnotsPerMinute, KnotsPerMinuteTolerance);
             AssertEx.EqualTolerance(KnotsPerSecondInOneMeterPerSecondSquared, meterpersecondsquared.KnotsPerSecond, KnotsPerSecondTolerance);
-            AssertEx.EqualTolerance(MeterPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(MicrometerPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.MicrometerPerSecondSquared, MicrometerPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(MillimeterPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.MillimeterPerSecondSquared, MillimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(NanometerPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.NanometerPerSecondSquared, NanometerPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(MetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(MicrometersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.MicrometersPerSecondSquared, MicrometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(MillimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.MillimetersPerSecondSquared, MillimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(NanometersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.NanometersPerSecondSquared, NanometersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(StandardGravityInOneMeterPerSecondSquared, meterpersecondsquared.StandardGravity, StandardGravityTolerance);
         }
 
         [Fact]
         public void FromValueAndUnit()
         {
-            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared).CentimeterPerSecondSquared, CentimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared).DecimeterPerSecondSquared, DecimeterPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.CentimeterPerSecondSquared).CentimetersPerSecondSquared, CentimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.DecimeterPerSecondSquared).DecimetersPerSecondSquared, DecimetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.FootPerSecondSquared).FeetPerSecondSquared, FeetPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.InchPerSecondSquared).InchesPerSecondSquared, InchesPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared).KilometerPerSecondSquared, KilometerPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.KilometerPerSecondSquared).KilometersPerSecondSquared, KilometersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.KnotPerHour).KnotsPerHour, KnotsPerHourTolerance);
             AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.KnotPerMinute).KnotsPerMinute, KnotsPerMinuteTolerance);
             AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.KnotPerSecond).KnotsPerSecond, KnotsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared).MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared).MicrometerPerSecondSquared, MicrometerPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared).MillimeterPerSecondSquared, MillimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared).NanometerPerSecondSquared, NanometerPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.MeterPerSecondSquared).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.MicrometerPerSecondSquared).MicrometersPerSecondSquared, MicrometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.MillimeterPerSecondSquared).MillimetersPerSecondSquared, MillimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.NanometerPerSecondSquared).NanometersPerSecondSquared, NanometersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(1, Acceleration.From(1, AccelerationUnit.StandardGravity).StandardGravity, StandardGravityTolerance);
         }
 
         [Fact]
         public void As()
         {
-            var meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1);
-            AssertEx.EqualTolerance(CentimeterPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.CentimeterPerSecondSquared), CentimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(DecimeterPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.DecimeterPerSecondSquared), DecimeterPerSecondSquaredTolerance);
+            var meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            AssertEx.EqualTolerance(CentimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.CentimeterPerSecondSquared), CentimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(DecimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.DecimeterPerSecondSquared), DecimetersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(FeetPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.FootPerSecondSquared), FeetPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(InchesPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.InchPerSecondSquared), InchesPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(KilometerPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.KilometerPerSecondSquared), KilometerPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(KilometersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.KilometerPerSecondSquared), KilometersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(KnotsPerHourInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.KnotPerHour), KnotsPerHourTolerance);
             AssertEx.EqualTolerance(KnotsPerMinuteInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.KnotPerMinute), KnotsPerMinuteTolerance);
             AssertEx.EqualTolerance(KnotsPerSecondInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.KnotPerSecond), KnotsPerSecondTolerance);
-            AssertEx.EqualTolerance(MeterPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.MeterPerSecondSquared), MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(MicrometerPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.MicrometerPerSecondSquared), MicrometerPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(MillimeterPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.MillimeterPerSecondSquared), MillimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(NanometerPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.NanometerPerSecondSquared), NanometerPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(MetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.MeterPerSecondSquared), MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(MicrometersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.MicrometerPerSecondSquared), MicrometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(MillimetersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.MillimeterPerSecondSquared), MillimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(NanometersPerSecondSquaredInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.NanometerPerSecondSquared), NanometersPerSecondSquaredTolerance);
             AssertEx.EqualTolerance(StandardGravityInOneMeterPerSecondSquared, meterpersecondsquared.As(AccelerationUnit.StandardGravity), StandardGravityTolerance);
         }
 
         [Fact]
         public void ConversionRoundTrip()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1);
-            AssertEx.EqualTolerance(1, Acceleration.FromCentimeterPerSecondSquared(meterpersecondsquared.CentimeterPerSecondSquared).MeterPerSecondSquared, CentimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromDecimeterPerSecondSquared(meterpersecondsquared.DecimeterPerSecondSquared).MeterPerSecondSquared, DecimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromFeetPerSecondSquared(meterpersecondsquared.FeetPerSecondSquared).MeterPerSecondSquared, FeetPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromInchesPerSecondSquared(meterpersecondsquared.InchesPerSecondSquared).MeterPerSecondSquared, InchesPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKilometerPerSecondSquared(meterpersecondsquared.KilometerPerSecondSquared).MeterPerSecondSquared, KilometerPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerHour(meterpersecondsquared.KnotsPerHour).MeterPerSecondSquared, KnotsPerHourTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerMinute(meterpersecondsquared.KnotsPerMinute).MeterPerSecondSquared, KnotsPerMinuteTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerSecond(meterpersecondsquared.KnotsPerSecond).MeterPerSecondSquared, KnotsPerSecondTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMeterPerSecondSquared(meterpersecondsquared.MeterPerSecondSquared).MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMicrometerPerSecondSquared(meterpersecondsquared.MicrometerPerSecondSquared).MeterPerSecondSquared, MicrometerPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromMillimeterPerSecondSquared(meterpersecondsquared.MillimeterPerSecondSquared).MeterPerSecondSquared, MillimeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromNanometerPerSecondSquared(meterpersecondsquared.NanometerPerSecondSquared).MeterPerSecondSquared, NanometerPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(1, Acceleration.FromStandardGravity(meterpersecondsquared.StandardGravity).MeterPerSecondSquared, StandardGravityTolerance);
+            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
+            AssertEx.EqualTolerance(1, Acceleration.FromCentimetersPerSecondSquared(meterpersecondsquared.CentimetersPerSecondSquared).MetersPerSecondSquared, CentimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromDecimetersPerSecondSquared(meterpersecondsquared.DecimetersPerSecondSquared).MetersPerSecondSquared, DecimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromFeetPerSecondSquared(meterpersecondsquared.FeetPerSecondSquared).MetersPerSecondSquared, FeetPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromInchesPerSecondSquared(meterpersecondsquared.InchesPerSecondSquared).MetersPerSecondSquared, InchesPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromKilometersPerSecondSquared(meterpersecondsquared.KilometersPerSecondSquared).MetersPerSecondSquared, KilometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerHour(meterpersecondsquared.KnotsPerHour).MetersPerSecondSquared, KnotsPerHourTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerMinute(meterpersecondsquared.KnotsPerMinute).MetersPerSecondSquared, KnotsPerMinuteTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromKnotsPerSecond(meterpersecondsquared.KnotsPerSecond).MetersPerSecondSquared, KnotsPerSecondTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromMetersPerSecondSquared(meterpersecondsquared.MetersPerSecondSquared).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromMicrometersPerSecondSquared(meterpersecondsquared.MicrometersPerSecondSquared).MetersPerSecondSquared, MicrometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromMillimetersPerSecondSquared(meterpersecondsquared.MillimetersPerSecondSquared).MetersPerSecondSquared, MillimetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromNanometersPerSecondSquared(meterpersecondsquared.NanometersPerSecondSquared).MetersPerSecondSquared, NanometersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(1, Acceleration.FromStandardGravity(meterpersecondsquared.StandardGravity).MetersPerSecondSquared, StandardGravityTolerance);
         }
 
         [Fact]
         public void ArithmeticOperators()
         {
-            Acceleration v = Acceleration.FromMeterPerSecondSquared(1);
-            AssertEx.EqualTolerance(-1, -v.MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (Acceleration.FromMeterPerSecondSquared(3)-v).MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (v + v).MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(10, (v*10).MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(10, (10*v).MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, (Acceleration.FromMeterPerSecondSquared(10)/5).MeterPerSecondSquared, MeterPerSecondSquaredTolerance);
-            AssertEx.EqualTolerance(2, Acceleration.FromMeterPerSecondSquared(10)/Acceleration.FromMeterPerSecondSquared(5), MeterPerSecondSquaredTolerance);
+            Acceleration v = Acceleration.FromMetersPerSecondSquared(1);
+            AssertEx.EqualTolerance(-1, -v.MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (Acceleration.FromMetersPerSecondSquared(3)-v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (v + v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(10, (v*10).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(10, (10*v).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, (Acceleration.FromMetersPerSecondSquared(10)/5).MetersPerSecondSquared, MetersPerSecondSquaredTolerance);
+            AssertEx.EqualTolerance(2, Acceleration.FromMetersPerSecondSquared(10)/Acceleration.FromMetersPerSecondSquared(5), MetersPerSecondSquaredTolerance);
         }
 
         [Fact]
         public void ComparisonOperators()
         {
-            Acceleration oneMeterPerSecondSquared = Acceleration.FromMeterPerSecondSquared(1);
-            Acceleration twoMeterPerSecondSquared = Acceleration.FromMeterPerSecondSquared(2);
-
-            Assert.True(oneMeterPerSecondSquared < twoMeterPerSecondSquared);
-            Assert.True(oneMeterPerSecondSquared <= twoMeterPerSecondSquared);
-            Assert.True(twoMeterPerSecondSquared > oneMeterPerSecondSquared);
-            Assert.True(twoMeterPerSecondSquared >= oneMeterPerSecondSquared);
-
-            Assert.False(oneMeterPerSecondSquared > twoMeterPerSecondSquared);
-            Assert.False(oneMeterPerSecondSquared >= twoMeterPerSecondSquared);
-            Assert.False(twoMeterPerSecondSquared < oneMeterPerSecondSquared);
-            Assert.False(twoMeterPerSecondSquared <= oneMeterPerSecondSquared);
+            Acceleration oneMeterPerSecondSquared = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration twoMetersPerSecondSquared = Acceleration.FromMetersPerSecondSquared(2);
+
+            Assert.True(oneMeterPerSecondSquared < twoMetersPerSecondSquared);
+            Assert.True(oneMeterPerSecondSquared <= twoMetersPerSecondSquared);
+            Assert.True(twoMetersPerSecondSquared > oneMeterPerSecondSquared);
+            Assert.True(twoMetersPerSecondSquared >= oneMeterPerSecondSquared);
+
+            Assert.False(oneMeterPerSecondSquared > twoMetersPerSecondSquared);
+            Assert.False(oneMeterPerSecondSquared >= twoMetersPerSecondSquared);
+            Assert.False(twoMetersPerSecondSquared < oneMeterPerSecondSquared);
+            Assert.False(twoMetersPerSecondSquared <= oneMeterPerSecondSquared);
         }
 
         [Fact]
         public void CompareToIsImplemented()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1);
+            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
             Assert.Equal(0, meterpersecondsquared.CompareTo(meterpersecondsquared));
             Assert.True(meterpersecondsquared.CompareTo(Acceleration.Zero) > 0);
             Assert.True(Acceleration.Zero.CompareTo(meterpersecondsquared) < 0);
@@ -199,14 +199,14 @@ public void CompareToIsImplemented()
         [Fact]
         public void CompareToThrowsOnTypeMismatch()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1);
+            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
             Assert.Throws<ArgumentException>(() => meterpersecondsquared.CompareTo(new object()));
         }
 
         [Fact]
         public void CompareToThrowsOnNull()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1);
+            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
             Assert.Throws<ArgumentNullException>(() => meterpersecondsquared.CompareTo(null));
         }
 
@@ -214,8 +214,8 @@ public void CompareToThrowsOnNull()
         [Fact]
         public void EqualityOperators()
         {
-            Acceleration a = Acceleration.FromMeterPerSecondSquared(1);
-            Acceleration b = Acceleration.FromMeterPerSecondSquared(2);
+            Acceleration a = Acceleration.FromMetersPerSecondSquared(1);
+            Acceleration b = Acceleration.FromMetersPerSecondSquared(2);
 
 // ReSharper disable EqualExpressionComparison
             Assert.True(a == a);
@@ -229,22 +229,22 @@ public void EqualityOperators()
         [Fact]
         public void EqualsIsImplemented()
         {
-            Acceleration v = Acceleration.FromMeterPerSecondSquared(1);
-            Assert.True(v.Equals(Acceleration.FromMeterPerSecondSquared(1), Acceleration.FromMeterPerSecondSquared(MeterPerSecondSquaredTolerance)));
-            Assert.False(v.Equals(Acceleration.Zero, Acceleration.FromMeterPerSecondSquared(MeterPerSecondSquaredTolerance)));
+            Acceleration v = Acceleration.FromMetersPerSecondSquared(1);
+            Assert.True(v.Equals(Acceleration.FromMetersPerSecondSquared(1), Acceleration.FromMetersPerSecondSquared(MetersPerSecondSquaredTolerance)));
+            Assert.False(v.Equals(Acceleration.Zero, Acceleration.FromMetersPerSecondSquared(MetersPerSecondSquaredTolerance)));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnTypeMismatch()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1);
+            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
             Assert.False(meterpersecondsquared.Equals(new object()));
         }
 
         [Fact]
         public void EqualsReturnsFalseOnNull()
         {
-            Acceleration meterpersecondsquared = Acceleration.FromMeterPerSecondSquared(1);
+            Acceleration meterpersecondsquared = Acceleration.FromMetersPerSecondSquared(1);
             Assert.False(meterpersecondsquared.Equals(null));
         }
     }
diff --git a/UnitsNet.Tests/IntOverloadTests.cs b/UnitsNet.Tests/IntOverloadTests.cs
index 9ab47bcd06..3a762ecb54 100644
--- a/UnitsNet.Tests/IntOverloadTests.cs
+++ b/UnitsNet.Tests/IntOverloadTests.cs
@@ -31,24 +31,24 @@ public class IntOverloadTests
         public static void CreatingQuantityWithDoubleBackingFieldFromIntReturnsCorrectValue()
         {
             int oneMeterPerSecondSquared = 1;
-            Acceleration acceleration = Acceleration.FromMeterPerSecondSquared(oneMeterPerSecondSquared);
-            Assert.Equal(1.0, acceleration.MeterPerSecondSquared);
+            Acceleration acceleration = Acceleration.FromMetersPerSecondSquared(oneMeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableIntReturnsCorrectValue()
         {
             int? oneMeterPerSecondSquared = 1;
-            Acceleration? acceleration = Acceleration.FromMeterPerSecondSquared(oneMeterPerSecondSquared);
+            Acceleration? acceleration = Acceleration.FromMetersPerSecondSquared(oneMeterPerSecondSquared);
             Assert.NotNull(acceleration);
-            Assert.Equal(1.0, acceleration.Value.MeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.Value.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableIntReturnsNullWhenGivenNull()
         {
             int? nullInt = null;
-            Acceleration? acceleration = Acceleration.FromMeterPerSecondSquared(nullInt);
+            Acceleration? acceleration = Acceleration.FromMetersPerSecondSquared(nullInt);
             Assert.Null(acceleration);
         }
 
@@ -56,24 +56,24 @@ public static void CreatingQuantityWithDoubleBackingFieldFromNullableIntReturnsN
         public static void CreatingQuantityWithDoubleBackingFieldFromIntWithExtensionMethodReturnsCorrectValue()
         {
             int oneMeterPerSecondSquared = 1;
-            Acceleration acceleration = oneMeterPerSecondSquared.MeterPerSecondSquared();
-            Assert.Equal(1.0, acceleration.MeterPerSecondSquared);
+            Acceleration acceleration = oneMeterPerSecondSquared.MetersPerSecondSquared();
+            Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableIntWithExtensionMethodReturnsCorrectValue()
         {
             int? oneMeterPerSecondSquared = 1;
-            Acceleration? acceleration = oneMeterPerSecondSquared.MeterPerSecondSquared();
+            Acceleration? acceleration = oneMeterPerSecondSquared.MetersPerSecondSquared();
             Assert.NotNull(acceleration);
-            Assert.Equal(1.0, acceleration.Value.MeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.Value.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableIntWithExtensionMethodReturnsNullWhenGivenNull()
         {
             int? nullInt = null;
-            Acceleration? acceleration = nullInt.MeterPerSecondSquared();
+            Acceleration? acceleration = nullInt.MetersPerSecondSquared();
             Assert.Null(acceleration);
         }
 
diff --git a/UnitsNet.Tests/LongOverloadTests.cs b/UnitsNet.Tests/LongOverloadTests.cs
index cf8982ebe9..d64ee9fa03 100644
--- a/UnitsNet.Tests/LongOverloadTests.cs
+++ b/UnitsNet.Tests/LongOverloadTests.cs
@@ -31,24 +31,24 @@ public class LongOverloadTests
         public static void CreatingQuantityWithDoubleBackingFieldFromLongReturnsCorrectValue()
         {
             long oneMeterPerSecondSquared = 1;
-            Acceleration acceleration = Acceleration.FromMeterPerSecondSquared(oneMeterPerSecondSquared);
-            Assert.Equal(1.0, acceleration.MeterPerSecondSquared);
+            Acceleration acceleration = Acceleration.FromMetersPerSecondSquared(oneMeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableLongReturnsCorrectValue()
         {
             long? oneMeterPerSecondSquared = 1;
-            Acceleration? acceleration = Acceleration.FromMeterPerSecondSquared(oneMeterPerSecondSquared);
+            Acceleration? acceleration = Acceleration.FromMetersPerSecondSquared(oneMeterPerSecondSquared);
             Assert.NotNull(acceleration);
-            Assert.Equal(1.0, acceleration.Value.MeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.Value.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableLongReturnsNullWhenGivenNull()
         {
             long? nullLong = null;
-            Acceleration? acceleration = Acceleration.FromMeterPerSecondSquared(nullLong);
+            Acceleration? acceleration = Acceleration.FromMetersPerSecondSquared(nullLong);
             Assert.Null(acceleration);
         }
 
@@ -56,24 +56,24 @@ public static void CreatingQuantityWithDoubleBackingFieldFromNullableLongReturns
         public static void CreatingQuantityWithDoubleBackingFieldFromLongWithExtensionMethodReturnsCorrectValue()
         {
             long oneMeterPerSecondSquared = 1;
-            Acceleration acceleration = oneMeterPerSecondSquared.MeterPerSecondSquared();
-            Assert.Equal(1.0, acceleration.MeterPerSecondSquared);
+            Acceleration acceleration = oneMeterPerSecondSquared.MetersPerSecondSquared();
+            Assert.Equal(1.0, acceleration.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableLongWithExtensionMethodReturnsCorrectValue()
         {
             long? oneMeterPerSecondSquared = 1;
-            Acceleration? acceleration = oneMeterPerSecondSquared.MeterPerSecondSquared();
+            Acceleration? acceleration = oneMeterPerSecondSquared.MetersPerSecondSquared();
             Assert.NotNull(acceleration);
-            Assert.Equal(1.0, acceleration.Value.MeterPerSecondSquared);
+            Assert.Equal(1.0, acceleration.Value.MetersPerSecondSquared);
         }
 
         [Fact]
         public static void CreatingQuantityWithDoubleBackingFieldFromNullableLongWithExtensionMethodReturnsNullWhenGivenNull()
         {
             long? nullLong = null;
-            Acceleration? acceleration = nullLong.MeterPerSecondSquared();
+            Acceleration? acceleration = nullLong.MetersPerSecondSquared();
             Assert.Null(acceleration);
         }
 
diff --git a/UnitsNet/CustomCode/Quantities/Force.extra.cs b/UnitsNet/CustomCode/Quantities/Force.extra.cs
index 60b8e750d3..6ae89c097c 100644
--- a/UnitsNet/CustomCode/Quantities/Force.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Force.extra.cs
@@ -44,12 +44,12 @@ public partial struct Force
 
         public static Acceleration operator /(Force force, Mass mass)
         {
-            return Acceleration.FromMeterPerSecondSquared(force.Newtons / mass.Kilograms);
+            return Acceleration.FromMetersPerSecondSquared(force.Newtons / mass.Kilograms);
         }
 
         public static Mass operator /(Force force, Acceleration mass)
         {
-            return Mass.FromKilograms(force.Newtons / mass.MeterPerSecondSquared);
+            return Mass.FromKilograms(force.Newtons / mass.MetersPerSecondSquared);
         }
 
         public static Pressure operator /(Force force, Area area)
@@ -86,7 +86,7 @@ public static Force FromPressureByArea(Pressure p, Area area)
 
         public static Force FromMassByAcceleration(Mass mass, Acceleration acceleration)
         {
-            return new Force(mass.Kilograms * acceleration.MeterPerSecondSquared);
+            return new Force(mass.Kilograms * acceleration.MetersPerSecondSquared);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/UnitsNet/CustomCode/Quantities/Mass.extra.cs b/UnitsNet/CustomCode/Quantities/Mass.extra.cs
index c87eff453f..4609cbf0a6 100644
--- a/UnitsNet/CustomCode/Quantities/Mass.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Mass.extra.cs
@@ -98,12 +98,12 @@ public static Mass FromStonePounds(double stone, double pounds)
 
         public static Force operator *(Mass mass, Acceleration acceleration)
         {
-            return Force.FromNewtons(mass.Kilograms*acceleration.MeterPerSecondSquared);
+            return Force.FromNewtons(mass.Kilograms*acceleration.MetersPerSecondSquared);
         }
 
         public static Force operator *(Acceleration acceleration, Mass mass)
         {
-            return Force.FromNewtons(mass.Kilograms*acceleration.MeterPerSecondSquared);
+            return Force.FromNewtons(mass.Kilograms*acceleration.MetersPerSecondSquared);
         }
 #endif
     }
@@ -137,4 +137,4 @@ public string ToString([CanBeNull] Culture cultureInfo)
                 Stone, stoneUnit, Math.Round(Pounds), poundUnit);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/UnitsNet/CustomCode/Quantities/Speed.extra.cs b/UnitsNet/CustomCode/Quantities/Speed.extra.cs
index 12b7841004..267d1e9ffc 100644
--- a/UnitsNet/CustomCode/Quantities/Speed.extra.cs
+++ b/UnitsNet/CustomCode/Quantities/Speed.extra.cs
@@ -39,7 +39,7 @@ public partial struct Speed
 #if !WINDOWS_UWP
         public static Acceleration operator /(Speed speed, TimeSpan timeSpan)
         {
-            return Acceleration.FromMeterPerSecondSquared(speed.MetersPerSecond / timeSpan.TotalSeconds);
+            return Acceleration.FromMetersPerSecondSquared(speed.MetersPerSecond / timeSpan.TotalSeconds);
         }
 
         public static Length operator *(Speed speed, TimeSpan timeSpan)
@@ -54,7 +54,7 @@ public partial struct Speed
 
         public static Acceleration operator /(Speed speed, Duration duration)
         {
-            return Acceleration.FromMeterPerSecondSquared(speed.MetersPerSecond / duration.Seconds);
+            return Acceleration.FromMetersPerSecondSquared(speed.MetersPerSecond / duration.Seconds);
         }
 
         public static Length operator *(Speed speed, Duration duration)
diff --git a/UnitsNet/GeneratedCode/Extensions/Number/NumberToAccelerationExtensions.g.cs b/UnitsNet/GeneratedCode/Extensions/Number/NumberToAccelerationExtensions.g.cs
index 4faf18fa9d..00bc3e4153 100644
--- a/UnitsNet/GeneratedCode/Extensions/Number/NumberToAccelerationExtensions.g.cs
+++ b/UnitsNet/GeneratedCode/Extensions/Number/NumberToAccelerationExtensions.g.cs
@@ -46,69 +46,69 @@ public static class NumberToAccelerationExtensions
     {
         #region CentimeterPerSecondSquared
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double)"/>
-        public static Acceleration CentimeterPerSecondSquared(this int value) => Acceleration.FromCentimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double)"/>
+        public static Acceleration CentimetersPerSecondSquared(this int value) => Acceleration.FromCentimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double?)"/>
-        public static Acceleration? CentimeterPerSecondSquared(this int? value) => Acceleration.FromCentimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double?)"/>
+        public static Acceleration? CentimetersPerSecondSquared(this int? value) => Acceleration.FromCentimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double)"/>
-        public static Acceleration CentimeterPerSecondSquared(this long value) => Acceleration.FromCentimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double)"/>
+        public static Acceleration CentimetersPerSecondSquared(this long value) => Acceleration.FromCentimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double?)"/>
-        public static Acceleration? CentimeterPerSecondSquared(this long? value) => Acceleration.FromCentimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double?)"/>
+        public static Acceleration? CentimetersPerSecondSquared(this long? value) => Acceleration.FromCentimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double)"/>
-        public static Acceleration CentimeterPerSecondSquared(this double value) => Acceleration.FromCentimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double)"/>
+        public static Acceleration CentimetersPerSecondSquared(this double value) => Acceleration.FromCentimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double?)"/>
-        public static Acceleration? CentimeterPerSecondSquared(this double? value) => Acceleration.FromCentimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double?)"/>
+        public static Acceleration? CentimetersPerSecondSquared(this double? value) => Acceleration.FromCentimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double)"/>
-        public static Acceleration CentimeterPerSecondSquared(this float value) => Acceleration.FromCentimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double)"/>
+        public static Acceleration CentimetersPerSecondSquared(this float value) => Acceleration.FromCentimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double?)"/>
-        public static Acceleration? CentimeterPerSecondSquared(this float? value) => Acceleration.FromCentimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double?)"/>
+        public static Acceleration? CentimetersPerSecondSquared(this float? value) => Acceleration.FromCentimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double)"/>
-        public static Acceleration CentimeterPerSecondSquared(this decimal value) => Acceleration.FromCentimeterPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double)"/>
+        public static Acceleration CentimetersPerSecondSquared(this decimal value) => Acceleration.FromCentimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromCentimeterPerSecondSquared(double?)"/>
-        public static Acceleration? CentimeterPerSecondSquared(this decimal? value) => Acceleration.FromCentimeterPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
+        /// <inheritdoc cref="Acceleration.FromCentimetersPerSecondSquared(double?)"/>
+        public static Acceleration? CentimetersPerSecondSquared(this decimal? value) => Acceleration.FromCentimetersPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
 
         #endregion
 
         #region DecimeterPerSecondSquared
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double)"/>
-        public static Acceleration DecimeterPerSecondSquared(this int value) => Acceleration.FromDecimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double)"/>
+        public static Acceleration DecimetersPerSecondSquared(this int value) => Acceleration.FromDecimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double?)"/>
-        public static Acceleration? DecimeterPerSecondSquared(this int? value) => Acceleration.FromDecimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double?)"/>
+        public static Acceleration? DecimetersPerSecondSquared(this int? value) => Acceleration.FromDecimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double)"/>
-        public static Acceleration DecimeterPerSecondSquared(this long value) => Acceleration.FromDecimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double)"/>
+        public static Acceleration DecimetersPerSecondSquared(this long value) => Acceleration.FromDecimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double?)"/>
-        public static Acceleration? DecimeterPerSecondSquared(this long? value) => Acceleration.FromDecimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double?)"/>
+        public static Acceleration? DecimetersPerSecondSquared(this long? value) => Acceleration.FromDecimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double)"/>
-        public static Acceleration DecimeterPerSecondSquared(this double value) => Acceleration.FromDecimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double)"/>
+        public static Acceleration DecimetersPerSecondSquared(this double value) => Acceleration.FromDecimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double?)"/>
-        public static Acceleration? DecimeterPerSecondSquared(this double? value) => Acceleration.FromDecimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double?)"/>
+        public static Acceleration? DecimetersPerSecondSquared(this double? value) => Acceleration.FromDecimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double)"/>
-        public static Acceleration DecimeterPerSecondSquared(this float value) => Acceleration.FromDecimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double)"/>
+        public static Acceleration DecimetersPerSecondSquared(this float value) => Acceleration.FromDecimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double?)"/>
-        public static Acceleration? DecimeterPerSecondSquared(this float? value) => Acceleration.FromDecimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double?)"/>
+        public static Acceleration? DecimetersPerSecondSquared(this float? value) => Acceleration.FromDecimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double)"/>
-        public static Acceleration DecimeterPerSecondSquared(this decimal value) => Acceleration.FromDecimeterPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double)"/>
+        public static Acceleration DecimetersPerSecondSquared(this decimal value) => Acceleration.FromDecimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromDecimeterPerSecondSquared(double?)"/>
-        public static Acceleration? DecimeterPerSecondSquared(this decimal? value) => Acceleration.FromDecimeterPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
+        /// <inheritdoc cref="Acceleration.FromDecimetersPerSecondSquared(double?)"/>
+        public static Acceleration? DecimetersPerSecondSquared(this decimal? value) => Acceleration.FromDecimetersPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
 
         #endregion
 
@@ -182,35 +182,35 @@ public static class NumberToAccelerationExtensions
 
         #region KilometerPerSecondSquared
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double)"/>
-        public static Acceleration KilometerPerSecondSquared(this int value) => Acceleration.FromKilometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double)"/>
+        public static Acceleration KilometersPerSecondSquared(this int value) => Acceleration.FromKilometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double?)"/>
-        public static Acceleration? KilometerPerSecondSquared(this int? value) => Acceleration.FromKilometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double?)"/>
+        public static Acceleration? KilometersPerSecondSquared(this int? value) => Acceleration.FromKilometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double)"/>
-        public static Acceleration KilometerPerSecondSquared(this long value) => Acceleration.FromKilometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double)"/>
+        public static Acceleration KilometersPerSecondSquared(this long value) => Acceleration.FromKilometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double?)"/>
-        public static Acceleration? KilometerPerSecondSquared(this long? value) => Acceleration.FromKilometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double?)"/>
+        public static Acceleration? KilometersPerSecondSquared(this long? value) => Acceleration.FromKilometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double)"/>
-        public static Acceleration KilometerPerSecondSquared(this double value) => Acceleration.FromKilometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double)"/>
+        public static Acceleration KilometersPerSecondSquared(this double value) => Acceleration.FromKilometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double?)"/>
-        public static Acceleration? KilometerPerSecondSquared(this double? value) => Acceleration.FromKilometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double?)"/>
+        public static Acceleration? KilometersPerSecondSquared(this double? value) => Acceleration.FromKilometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double)"/>
-        public static Acceleration KilometerPerSecondSquared(this float value) => Acceleration.FromKilometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double)"/>
+        public static Acceleration KilometersPerSecondSquared(this float value) => Acceleration.FromKilometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double?)"/>
-        public static Acceleration? KilometerPerSecondSquared(this float? value) => Acceleration.FromKilometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double?)"/>
+        public static Acceleration? KilometersPerSecondSquared(this float? value) => Acceleration.FromKilometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double)"/>
-        public static Acceleration KilometerPerSecondSquared(this decimal value) => Acceleration.FromKilometerPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double)"/>
+        public static Acceleration KilometersPerSecondSquared(this decimal value) => Acceleration.FromKilometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromKilometerPerSecondSquared(double?)"/>
-        public static Acceleration? KilometerPerSecondSquared(this decimal? value) => Acceleration.FromKilometerPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
+        /// <inheritdoc cref="Acceleration.FromKilometersPerSecondSquared(double?)"/>
+        public static Acceleration? KilometersPerSecondSquared(this decimal? value) => Acceleration.FromKilometersPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
 
         #endregion
 
@@ -318,137 +318,137 @@ public static class NumberToAccelerationExtensions
 
         #region MeterPerSecondSquared
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double)"/>
-        public static Acceleration MeterPerSecondSquared(this int value) => Acceleration.FromMeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double)"/>
+        public static Acceleration MetersPerSecondSquared(this int value) => Acceleration.FromMetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double?)"/>
-        public static Acceleration? MeterPerSecondSquared(this int? value) => Acceleration.FromMeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double?)"/>
+        public static Acceleration? MetersPerSecondSquared(this int? value) => Acceleration.FromMetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double)"/>
-        public static Acceleration MeterPerSecondSquared(this long value) => Acceleration.FromMeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double)"/>
+        public static Acceleration MetersPerSecondSquared(this long value) => Acceleration.FromMetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double?)"/>
-        public static Acceleration? MeterPerSecondSquared(this long? value) => Acceleration.FromMeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double?)"/>
+        public static Acceleration? MetersPerSecondSquared(this long? value) => Acceleration.FromMetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double)"/>
-        public static Acceleration MeterPerSecondSquared(this double value) => Acceleration.FromMeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double)"/>
+        public static Acceleration MetersPerSecondSquared(this double value) => Acceleration.FromMetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double?)"/>
-        public static Acceleration? MeterPerSecondSquared(this double? value) => Acceleration.FromMeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double?)"/>
+        public static Acceleration? MetersPerSecondSquared(this double? value) => Acceleration.FromMetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double)"/>
-        public static Acceleration MeterPerSecondSquared(this float value) => Acceleration.FromMeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double)"/>
+        public static Acceleration MetersPerSecondSquared(this float value) => Acceleration.FromMetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double?)"/>
-        public static Acceleration? MeterPerSecondSquared(this float? value) => Acceleration.FromMeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double?)"/>
+        public static Acceleration? MetersPerSecondSquared(this float? value) => Acceleration.FromMetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double)"/>
-        public static Acceleration MeterPerSecondSquared(this decimal value) => Acceleration.FromMeterPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double)"/>
+        public static Acceleration MetersPerSecondSquared(this decimal value) => Acceleration.FromMetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMeterPerSecondSquared(double?)"/>
-        public static Acceleration? MeterPerSecondSquared(this decimal? value) => Acceleration.FromMeterPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
+        /// <inheritdoc cref="Acceleration.FromMetersPerSecondSquared(double?)"/>
+        public static Acceleration? MetersPerSecondSquared(this decimal? value) => Acceleration.FromMetersPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
 
         #endregion
 
         #region MicrometerPerSecondSquared
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double)"/>
-        public static Acceleration MicrometerPerSecondSquared(this int value) => Acceleration.FromMicrometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double)"/>
+        public static Acceleration MicrometersPerSecondSquared(this int value) => Acceleration.FromMicrometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double?)"/>
-        public static Acceleration? MicrometerPerSecondSquared(this int? value) => Acceleration.FromMicrometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double?)"/>
+        public static Acceleration? MicrometersPerSecondSquared(this int? value) => Acceleration.FromMicrometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double)"/>
-        public static Acceleration MicrometerPerSecondSquared(this long value) => Acceleration.FromMicrometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double)"/>
+        public static Acceleration MicrometersPerSecondSquared(this long value) => Acceleration.FromMicrometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double?)"/>
-        public static Acceleration? MicrometerPerSecondSquared(this long? value) => Acceleration.FromMicrometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double?)"/>
+        public static Acceleration? MicrometersPerSecondSquared(this long? value) => Acceleration.FromMicrometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double)"/>
-        public static Acceleration MicrometerPerSecondSquared(this double value) => Acceleration.FromMicrometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double)"/>
+        public static Acceleration MicrometersPerSecondSquared(this double value) => Acceleration.FromMicrometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double?)"/>
-        public static Acceleration? MicrometerPerSecondSquared(this double? value) => Acceleration.FromMicrometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double?)"/>
+        public static Acceleration? MicrometersPerSecondSquared(this double? value) => Acceleration.FromMicrometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double)"/>
-        public static Acceleration MicrometerPerSecondSquared(this float value) => Acceleration.FromMicrometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double)"/>
+        public static Acceleration MicrometersPerSecondSquared(this float value) => Acceleration.FromMicrometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double?)"/>
-        public static Acceleration? MicrometerPerSecondSquared(this float? value) => Acceleration.FromMicrometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double?)"/>
+        public static Acceleration? MicrometersPerSecondSquared(this float? value) => Acceleration.FromMicrometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double)"/>
-        public static Acceleration MicrometerPerSecondSquared(this decimal value) => Acceleration.FromMicrometerPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double)"/>
+        public static Acceleration MicrometersPerSecondSquared(this decimal value) => Acceleration.FromMicrometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMicrometerPerSecondSquared(double?)"/>
-        public static Acceleration? MicrometerPerSecondSquared(this decimal? value) => Acceleration.FromMicrometerPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
+        /// <inheritdoc cref="Acceleration.FromMicrometersPerSecondSquared(double?)"/>
+        public static Acceleration? MicrometersPerSecondSquared(this decimal? value) => Acceleration.FromMicrometersPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
 
         #endregion
 
         #region MillimeterPerSecondSquared
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double)"/>
-        public static Acceleration MillimeterPerSecondSquared(this int value) => Acceleration.FromMillimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double)"/>
+        public static Acceleration MillimetersPerSecondSquared(this int value) => Acceleration.FromMillimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double?)"/>
-        public static Acceleration? MillimeterPerSecondSquared(this int? value) => Acceleration.FromMillimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double?)"/>
+        public static Acceleration? MillimetersPerSecondSquared(this int? value) => Acceleration.FromMillimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double)"/>
-        public static Acceleration MillimeterPerSecondSquared(this long value) => Acceleration.FromMillimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double)"/>
+        public static Acceleration MillimetersPerSecondSquared(this long value) => Acceleration.FromMillimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double?)"/>
-        public static Acceleration? MillimeterPerSecondSquared(this long? value) => Acceleration.FromMillimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double?)"/>
+        public static Acceleration? MillimetersPerSecondSquared(this long? value) => Acceleration.FromMillimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double)"/>
-        public static Acceleration MillimeterPerSecondSquared(this double value) => Acceleration.FromMillimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double)"/>
+        public static Acceleration MillimetersPerSecondSquared(this double value) => Acceleration.FromMillimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double?)"/>
-        public static Acceleration? MillimeterPerSecondSquared(this double? value) => Acceleration.FromMillimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double?)"/>
+        public static Acceleration? MillimetersPerSecondSquared(this double? value) => Acceleration.FromMillimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double)"/>
-        public static Acceleration MillimeterPerSecondSquared(this float value) => Acceleration.FromMillimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double)"/>
+        public static Acceleration MillimetersPerSecondSquared(this float value) => Acceleration.FromMillimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double?)"/>
-        public static Acceleration? MillimeterPerSecondSquared(this float? value) => Acceleration.FromMillimeterPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double?)"/>
+        public static Acceleration? MillimetersPerSecondSquared(this float? value) => Acceleration.FromMillimetersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double)"/>
-        public static Acceleration MillimeterPerSecondSquared(this decimal value) => Acceleration.FromMillimeterPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double)"/>
+        public static Acceleration MillimetersPerSecondSquared(this decimal value) => Acceleration.FromMillimetersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromMillimeterPerSecondSquared(double?)"/>
-        public static Acceleration? MillimeterPerSecondSquared(this decimal? value) => Acceleration.FromMillimeterPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
+        /// <inheritdoc cref="Acceleration.FromMillimetersPerSecondSquared(double?)"/>
+        public static Acceleration? MillimetersPerSecondSquared(this decimal? value) => Acceleration.FromMillimetersPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
 
         #endregion
 
         #region NanometerPerSecondSquared
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double)"/>
-        public static Acceleration NanometerPerSecondSquared(this int value) => Acceleration.FromNanometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double)"/>
+        public static Acceleration NanometersPerSecondSquared(this int value) => Acceleration.FromNanometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double?)"/>
-        public static Acceleration? NanometerPerSecondSquared(this int? value) => Acceleration.FromNanometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double?)"/>
+        public static Acceleration? NanometersPerSecondSquared(this int? value) => Acceleration.FromNanometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double)"/>
-        public static Acceleration NanometerPerSecondSquared(this long value) => Acceleration.FromNanometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double)"/>
+        public static Acceleration NanometersPerSecondSquared(this long value) => Acceleration.FromNanometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double?)"/>
-        public static Acceleration? NanometerPerSecondSquared(this long? value) => Acceleration.FromNanometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double?)"/>
+        public static Acceleration? NanometersPerSecondSquared(this long? value) => Acceleration.FromNanometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double)"/>
-        public static Acceleration NanometerPerSecondSquared(this double value) => Acceleration.FromNanometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double)"/>
+        public static Acceleration NanometersPerSecondSquared(this double value) => Acceleration.FromNanometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double?)"/>
-        public static Acceleration? NanometerPerSecondSquared(this double? value) => Acceleration.FromNanometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double?)"/>
+        public static Acceleration? NanometersPerSecondSquared(this double? value) => Acceleration.FromNanometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double)"/>
-        public static Acceleration NanometerPerSecondSquared(this float value) => Acceleration.FromNanometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double)"/>
+        public static Acceleration NanometersPerSecondSquared(this float value) => Acceleration.FromNanometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double?)"/>
-        public static Acceleration? NanometerPerSecondSquared(this float? value) => Acceleration.FromNanometerPerSecondSquared(value);
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double?)"/>
+        public static Acceleration? NanometersPerSecondSquared(this float? value) => Acceleration.FromNanometersPerSecondSquared(value);
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double)"/>
-        public static Acceleration NanometerPerSecondSquared(this decimal value) => Acceleration.FromNanometerPerSecondSquared(Convert.ToDouble(value));
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double)"/>
+        public static Acceleration NanometersPerSecondSquared(this decimal value) => Acceleration.FromNanometersPerSecondSquared(Convert.ToDouble(value));
 
-        /// <inheritdoc cref="Acceleration.FromNanometerPerSecondSquared(double?)"/>
-        public static Acceleration? NanometerPerSecondSquared(this decimal? value) => Acceleration.FromNanometerPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
+        /// <inheritdoc cref="Acceleration.FromNanometersPerSecondSquared(double?)"/>
+        public static Acceleration? NanometersPerSecondSquared(this decimal? value) => Acceleration.FromNanometersPerSecondSquared(value == null ? (double?)null : Convert.ToDouble(value.Value));
 
         #endregion
 
diff --git a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
index 8300b4c61c..3a9872cd8a 100644
--- a/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/Acceleration.g.cs
@@ -96,9 +96,9 @@ public Acceleration()
 #endif
 
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
-        public Acceleration(double meterpersecondsquared)
+        public Acceleration(double meterspersecondsquared)
         {
-            _value = Convert.ToDouble(meterpersecondsquared);
+            _value = Convert.ToDouble(meterspersecondsquared);
             _unit = BaseUnit;
         }
 
@@ -123,28 +123,28 @@ public Acceleration(double meterpersecondsquared)
         /// <summary>
         ///     Creates the quantity with the given value assuming the base unit MeterPerSecondSquared.
         /// </summary>
-        /// <param name="meterpersecondsquared">Value assuming base unit MeterPerSecondSquared.</param>
+        /// <param name="meterspersecondsquared">Value assuming base unit MeterPerSecondSquared.</param>
 #if WINDOWS_UWP
         private
 #else
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public
 #endif
-        Acceleration(long meterpersecondsquared) : this(Convert.ToDouble(meterpersecondsquared), BaseUnit) { }
+        Acceleration(long meterspersecondsquared) : this(Convert.ToDouble(meterspersecondsquared), BaseUnit) { }
 
         // Windows Runtime Component does not allow public methods/ctors with same number of parameters: https://msdn.microsoft.com/en-us/library/br230301.aspx#Overloaded methods
         // Windows Runtime Component does not support decimal type
         /// <summary>
         ///     Creates the quantity with the given value assuming the base unit MeterPerSecondSquared.
         /// </summary>
-        /// <param name="meterpersecondsquared">Value assuming base unit MeterPerSecondSquared.</param>
+        /// <param name="meterspersecondsquared">Value assuming base unit MeterPerSecondSquared.</param>
 #if WINDOWS_UWP
         private
 #else
         [Obsolete("Use the constructor that takes a unit parameter. This constructor will be removed in a future version.")]
         public
 #endif
-        Acceleration(decimal meterpersecondsquared) : this(Convert.ToDouble(meterpersecondsquared), BaseUnit) { }
+        Acceleration(decimal meterspersecondsquared) : this(Convert.ToDouble(meterspersecondsquared), BaseUnit) { }
 
         #region Properties
 
@@ -163,13 +163,13 @@ public Acceleration(double meterpersecondsquared)
         /// </summary>
         public static AccelerationUnit[] Units { get; } = Enum.GetValues(typeof(AccelerationUnit)).Cast<AccelerationUnit>().ToArray();
         /// <summary>
-        ///     Get Acceleration in CentimeterPerSecondSquared.
+        ///     Get Acceleration in CentimetersPerSecondSquared.
         /// </summary>
-        public double CentimeterPerSecondSquared => As(AccelerationUnit.CentimeterPerSecondSquared);
+        public double CentimetersPerSecondSquared => As(AccelerationUnit.CentimeterPerSecondSquared);
         /// <summary>
-        ///     Get Acceleration in DecimeterPerSecondSquared.
+        ///     Get Acceleration in DecimetersPerSecondSquared.
         /// </summary>
-        public double DecimeterPerSecondSquared => As(AccelerationUnit.DecimeterPerSecondSquared);
+        public double DecimetersPerSecondSquared => As(AccelerationUnit.DecimeterPerSecondSquared);
         /// <summary>
         ///     Get Acceleration in FeetPerSecondSquared.
         /// </summary>
@@ -179,9 +179,9 @@ public Acceleration(double meterpersecondsquared)
         /// </summary>
         public double InchesPerSecondSquared => As(AccelerationUnit.InchPerSecondSquared);
         /// <summary>
-        ///     Get Acceleration in KilometerPerSecondSquared.
+        ///     Get Acceleration in KilometersPerSecondSquared.
         /// </summary>
-        public double KilometerPerSecondSquared => As(AccelerationUnit.KilometerPerSecondSquared);
+        public double KilometersPerSecondSquared => As(AccelerationUnit.KilometerPerSecondSquared);
         /// <summary>
         ///     Get Acceleration in KnotsPerHour.
         /// </summary>
@@ -195,21 +195,21 @@ public Acceleration(double meterpersecondsquared)
         /// </summary>
         public double KnotsPerSecond => As(AccelerationUnit.KnotPerSecond);
         /// <summary>
-        ///     Get Acceleration in MeterPerSecondSquared.
+        ///     Get Acceleration in MetersPerSecondSquared.
         /// </summary>
-        public double MeterPerSecondSquared => As(AccelerationUnit.MeterPerSecondSquared);
+        public double MetersPerSecondSquared => As(AccelerationUnit.MeterPerSecondSquared);
         /// <summary>
-        ///     Get Acceleration in MicrometerPerSecondSquared.
+        ///     Get Acceleration in MicrometersPerSecondSquared.
         /// </summary>
-        public double MicrometerPerSecondSquared => As(AccelerationUnit.MicrometerPerSecondSquared);
+        public double MicrometersPerSecondSquared => As(AccelerationUnit.MicrometerPerSecondSquared);
         /// <summary>
-        ///     Get Acceleration in MillimeterPerSecondSquared.
+        ///     Get Acceleration in MillimetersPerSecondSquared.
         /// </summary>
-        public double MillimeterPerSecondSquared => As(AccelerationUnit.MillimeterPerSecondSquared);
+        public double MillimetersPerSecondSquared => As(AccelerationUnit.MillimeterPerSecondSquared);
         /// <summary>
-        ///     Get Acceleration in NanometerPerSecondSquared.
+        ///     Get Acceleration in NanometersPerSecondSquared.
         /// </summary>
-        public double NanometerPerSecondSquared => As(AccelerationUnit.NanometerPerSecondSquared);
+        public double NanometersPerSecondSquared => As(AccelerationUnit.NanometerPerSecondSquared);
         /// <summary>
         ///     Get Acceleration in StandardGravity.
         /// </summary>
@@ -222,30 +222,30 @@ public Acceleration(double meterpersecondsquared)
         public static Acceleration Zero => new Acceleration(0, BaseUnit);
 
         /// <summary>
-        ///     Get Acceleration from CentimeterPerSecondSquared.
+        ///     Get Acceleration from CentimetersPerSecondSquared.
         /// </summary>
 #if WINDOWS_UWP
         [Windows.Foundation.Metadata.DefaultOverload]
-        public static Acceleration FromCentimeterPerSecondSquared(double centimeterpersecondsquared)
+        public static Acceleration FromCentimetersPerSecondSquared(double centimeterspersecondsquared)
 #else
-        public static Acceleration FromCentimeterPerSecondSquared(QuantityValue centimeterpersecondsquared)
+        public static Acceleration FromCentimetersPerSecondSquared(QuantityValue centimeterspersecondsquared)
 #endif
         {
-            double value = (double) centimeterpersecondsquared;
+            double value = (double) centimeterspersecondsquared;
             return new Acceleration(value, AccelerationUnit.CentimeterPerSecondSquared);
         }
 
         /// <summary>
-        ///     Get Acceleration from DecimeterPerSecondSquared.
+        ///     Get Acceleration from DecimetersPerSecondSquared.
         /// </summary>
 #if WINDOWS_UWP
         [Windows.Foundation.Metadata.DefaultOverload]
-        public static Acceleration FromDecimeterPerSecondSquared(double decimeterpersecondsquared)
+        public static Acceleration FromDecimetersPerSecondSquared(double decimeterspersecondsquared)
 #else
-        public static Acceleration FromDecimeterPerSecondSquared(QuantityValue decimeterpersecondsquared)
+        public static Acceleration FromDecimetersPerSecondSquared(QuantityValue decimeterspersecondsquared)
 #endif
         {
-            double value = (double) decimeterpersecondsquared;
+            double value = (double) decimeterspersecondsquared;
             return new Acceleration(value, AccelerationUnit.DecimeterPerSecondSquared);
         }
 
@@ -278,16 +278,16 @@ public static Acceleration FromInchesPerSecondSquared(QuantityValue inchespersec
         }
 
         /// <summary>
-        ///     Get Acceleration from KilometerPerSecondSquared.
+        ///     Get Acceleration from KilometersPerSecondSquared.
         /// </summary>
 #if WINDOWS_UWP
         [Windows.Foundation.Metadata.DefaultOverload]
-        public static Acceleration FromKilometerPerSecondSquared(double kilometerpersecondsquared)
+        public static Acceleration FromKilometersPerSecondSquared(double kilometerspersecondsquared)
 #else
-        public static Acceleration FromKilometerPerSecondSquared(QuantityValue kilometerpersecondsquared)
+        public static Acceleration FromKilometersPerSecondSquared(QuantityValue kilometerspersecondsquared)
 #endif
         {
-            double value = (double) kilometerpersecondsquared;
+            double value = (double) kilometerspersecondsquared;
             return new Acceleration(value, AccelerationUnit.KilometerPerSecondSquared);
         }
 
@@ -334,58 +334,58 @@ public static Acceleration FromKnotsPerSecond(QuantityValue knotspersecond)
         }
 
         /// <summary>
-        ///     Get Acceleration from MeterPerSecondSquared.
+        ///     Get Acceleration from MetersPerSecondSquared.
         /// </summary>
 #if WINDOWS_UWP
         [Windows.Foundation.Metadata.DefaultOverload]
-        public static Acceleration FromMeterPerSecondSquared(double meterpersecondsquared)
+        public static Acceleration FromMetersPerSecondSquared(double meterspersecondsquared)
 #else
-        public static Acceleration FromMeterPerSecondSquared(QuantityValue meterpersecondsquared)
+        public static Acceleration FromMetersPerSecondSquared(QuantityValue meterspersecondsquared)
 #endif
         {
-            double value = (double) meterpersecondsquared;
+            double value = (double) meterspersecondsquared;
             return new Acceleration(value, AccelerationUnit.MeterPerSecondSquared);
         }
 
         /// <summary>
-        ///     Get Acceleration from MicrometerPerSecondSquared.
+        ///     Get Acceleration from MicrometersPerSecondSquared.
         /// </summary>
 #if WINDOWS_UWP
         [Windows.Foundation.Metadata.DefaultOverload]
-        public static Acceleration FromMicrometerPerSecondSquared(double micrometerpersecondsquared)
+        public static Acceleration FromMicrometersPerSecondSquared(double micrometerspersecondsquared)
 #else
-        public static Acceleration FromMicrometerPerSecondSquared(QuantityValue micrometerpersecondsquared)
+        public static Acceleration FromMicrometersPerSecondSquared(QuantityValue micrometerspersecondsquared)
 #endif
         {
-            double value = (double) micrometerpersecondsquared;
+            double value = (double) micrometerspersecondsquared;
             return new Acceleration(value, AccelerationUnit.MicrometerPerSecondSquared);
         }
 
         /// <summary>
-        ///     Get Acceleration from MillimeterPerSecondSquared.
+        ///     Get Acceleration from MillimetersPerSecondSquared.
         /// </summary>
 #if WINDOWS_UWP
         [Windows.Foundation.Metadata.DefaultOverload]
-        public static Acceleration FromMillimeterPerSecondSquared(double millimeterpersecondsquared)
+        public static Acceleration FromMillimetersPerSecondSquared(double millimeterspersecondsquared)
 #else
-        public static Acceleration FromMillimeterPerSecondSquared(QuantityValue millimeterpersecondsquared)
+        public static Acceleration FromMillimetersPerSecondSquared(QuantityValue millimeterspersecondsquared)
 #endif
         {
-            double value = (double) millimeterpersecondsquared;
+            double value = (double) millimeterspersecondsquared;
             return new Acceleration(value, AccelerationUnit.MillimeterPerSecondSquared);
         }
 
         /// <summary>
-        ///     Get Acceleration from NanometerPerSecondSquared.
+        ///     Get Acceleration from NanometersPerSecondSquared.
         /// </summary>
 #if WINDOWS_UWP
         [Windows.Foundation.Metadata.DefaultOverload]
-        public static Acceleration FromNanometerPerSecondSquared(double nanometerpersecondsquared)
+        public static Acceleration FromNanometersPerSecondSquared(double nanometerspersecondsquared)
 #else
-        public static Acceleration FromNanometerPerSecondSquared(QuantityValue nanometerpersecondsquared)
+        public static Acceleration FromNanometersPerSecondSquared(QuantityValue nanometerspersecondsquared)
 #endif
         {
-            double value = (double) nanometerpersecondsquared;
+            double value = (double) nanometerspersecondsquared;
             return new Acceleration(value, AccelerationUnit.NanometerPerSecondSquared);
         }
 
@@ -406,13 +406,13 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
         // Windows Runtime Component does not support nullable types (double?): https://msdn.microsoft.com/en-us/library/br230301.aspx
 #if !WINDOWS_UWP
         /// <summary>
-        ///     Get nullable Acceleration from nullable CentimeterPerSecondSquared.
+        ///     Get nullable Acceleration from nullable CentimetersPerSecondSquared.
         /// </summary>
-        public static Acceleration? FromCentimeterPerSecondSquared(QuantityValue? centimeterpersecondsquared)
+        public static Acceleration? FromCentimetersPerSecondSquared(QuantityValue? centimeterspersecondsquared)
         {
-            if (centimeterpersecondsquared.HasValue)
+            if (centimeterspersecondsquared.HasValue)
             {
-                return FromCentimeterPerSecondSquared(centimeterpersecondsquared.Value);
+                return FromCentimetersPerSecondSquared(centimeterspersecondsquared.Value);
             }
             else
             {
@@ -421,13 +421,13 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
         }
 
         /// <summary>
-        ///     Get nullable Acceleration from nullable DecimeterPerSecondSquared.
+        ///     Get nullable Acceleration from nullable DecimetersPerSecondSquared.
         /// </summary>
-        public static Acceleration? FromDecimeterPerSecondSquared(QuantityValue? decimeterpersecondsquared)
+        public static Acceleration? FromDecimetersPerSecondSquared(QuantityValue? decimeterspersecondsquared)
         {
-            if (decimeterpersecondsquared.HasValue)
+            if (decimeterspersecondsquared.HasValue)
             {
-                return FromDecimeterPerSecondSquared(decimeterpersecondsquared.Value);
+                return FromDecimetersPerSecondSquared(decimeterspersecondsquared.Value);
             }
             else
             {
@@ -466,13 +466,13 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
         }
 
         /// <summary>
-        ///     Get nullable Acceleration from nullable KilometerPerSecondSquared.
+        ///     Get nullable Acceleration from nullable KilometersPerSecondSquared.
         /// </summary>
-        public static Acceleration? FromKilometerPerSecondSquared(QuantityValue? kilometerpersecondsquared)
+        public static Acceleration? FromKilometersPerSecondSquared(QuantityValue? kilometerspersecondsquared)
         {
-            if (kilometerpersecondsquared.HasValue)
+            if (kilometerspersecondsquared.HasValue)
             {
-                return FromKilometerPerSecondSquared(kilometerpersecondsquared.Value);
+                return FromKilometersPerSecondSquared(kilometerspersecondsquared.Value);
             }
             else
             {
@@ -526,13 +526,13 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
         }
 
         /// <summary>
-        ///     Get nullable Acceleration from nullable MeterPerSecondSquared.
+        ///     Get nullable Acceleration from nullable MetersPerSecondSquared.
         /// </summary>
-        public static Acceleration? FromMeterPerSecondSquared(QuantityValue? meterpersecondsquared)
+        public static Acceleration? FromMetersPerSecondSquared(QuantityValue? meterspersecondsquared)
         {
-            if (meterpersecondsquared.HasValue)
+            if (meterspersecondsquared.HasValue)
             {
-                return FromMeterPerSecondSquared(meterpersecondsquared.Value);
+                return FromMetersPerSecondSquared(meterspersecondsquared.Value);
             }
             else
             {
@@ -541,13 +541,13 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
         }
 
         /// <summary>
-        ///     Get nullable Acceleration from nullable MicrometerPerSecondSquared.
+        ///     Get nullable Acceleration from nullable MicrometersPerSecondSquared.
         /// </summary>
-        public static Acceleration? FromMicrometerPerSecondSquared(QuantityValue? micrometerpersecondsquared)
+        public static Acceleration? FromMicrometersPerSecondSquared(QuantityValue? micrometerspersecondsquared)
         {
-            if (micrometerpersecondsquared.HasValue)
+            if (micrometerspersecondsquared.HasValue)
             {
-                return FromMicrometerPerSecondSquared(micrometerpersecondsquared.Value);
+                return FromMicrometersPerSecondSquared(micrometerspersecondsquared.Value);
             }
             else
             {
@@ -556,13 +556,13 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
         }
 
         /// <summary>
-        ///     Get nullable Acceleration from nullable MillimeterPerSecondSquared.
+        ///     Get nullable Acceleration from nullable MillimetersPerSecondSquared.
         /// </summary>
-        public static Acceleration? FromMillimeterPerSecondSquared(QuantityValue? millimeterpersecondsquared)
+        public static Acceleration? FromMillimetersPerSecondSquared(QuantityValue? millimeterspersecondsquared)
         {
-            if (millimeterpersecondsquared.HasValue)
+            if (millimeterspersecondsquared.HasValue)
             {
-                return FromMillimeterPerSecondSquared(millimeterpersecondsquared.Value);
+                return FromMillimetersPerSecondSquared(millimeterspersecondsquared.Value);
             }
             else
             {
@@ -571,13 +571,13 @@ public static Acceleration FromStandardGravity(QuantityValue standardgravity)
         }
 
         /// <summary>
-        ///     Get nullable Acceleration from nullable NanometerPerSecondSquared.
+        ///     Get nullable Acceleration from nullable NanometersPerSecondSquared.
         /// </summary>
-        public static Acceleration? FromNanometerPerSecondSquared(QuantityValue? nanometerpersecondsquared)
+        public static Acceleration? FromNanometersPerSecondSquared(QuantityValue? nanometerspersecondsquared)
         {
-            if (nanometerpersecondsquared.HasValue)
+            if (nanometerspersecondsquared.HasValue)
             {
-                return FromNanometerPerSecondSquared(nanometerpersecondsquared.Value);
+                return FromNanometersPerSecondSquared(nanometerspersecondsquared.Value);
             }
             else
             {
@@ -716,7 +716,7 @@ public static string GetAbbreviation(
 
         public static double operator /(Acceleration left, Acceleration right)
         {
-            return left.MeterPerSecondSquared / right.MeterPerSecondSquared;
+            return left.MetersPerSecondSquared / right.MetersPerSecondSquared;
         }
 #endif
 
@@ -739,7 +739,7 @@ public int CompareTo(object obj)
 #endif
         int CompareTo(Acceleration other)
         {
-            return AsBaseUnitMeterPerSecondSquared().CompareTo(other.AsBaseUnitMeterPerSecondSquared());
+            return AsBaseUnitMetersPerSecondSquared().CompareTo(other.AsBaseUnitMetersPerSecondSquared());
         }
 
         // Windows Runtime Component does not allow operator overloads: https://msdn.microsoft.com/en-us/library/br230301.aspx
@@ -787,7 +787,7 @@ public override bool Equals(object obj)
                 return false;
             }
 
-            return AsBaseUnitMeterPerSecondSquared().Equals(((Acceleration) obj).AsBaseUnitMeterPerSecondSquared());
+            return AsBaseUnitMetersPerSecondSquared().Equals(((Acceleration) obj).AsBaseUnitMetersPerSecondSquared());
         }
 
         /// <summary>
@@ -800,7 +800,7 @@ public override bool Equals(object obj)
         /// <returns>True if the difference between the two values is not greater than the specified max.</returns>
         public bool Equals(Acceleration other, Acceleration maxError)
         {
-            return Math.Abs(AsBaseUnitMeterPerSecondSquared() - other.AsBaseUnitMeterPerSecondSquared()) <= maxError.AsBaseUnitMeterPerSecondSquared();
+            return Math.Abs(AsBaseUnitMetersPerSecondSquared() - other.AsBaseUnitMetersPerSecondSquared()) <= maxError.AsBaseUnitMetersPerSecondSquared();
         }
 
         public override int GetHashCode()
@@ -823,7 +823,7 @@ public double As(AccelerationUnit unit)
                 return (double)Value;
             }
 
-            double baseUnitValue = AsBaseUnitMeterPerSecondSquared();
+            double baseUnitValue = AsBaseUnitMetersPerSecondSquared();
 
             switch (unit)
             {
@@ -927,7 +927,7 @@ public static Acceleration Parse(
                     double parsedValue = double.Parse(value, formatProvider2);
                     AccelerationUnit parsedUnit = ParseUnit(unit, formatProvider2);
                     return From(parsedValue, parsedUnit);
-                }, (x, y) => FromMeterPerSecondSquared(x.MeterPerSecondSquared + y.MeterPerSecondSquared));
+                }, (x, y) => FromMetersPerSecondSquared(x.MetersPerSecondSquared + y.MetersPerSecondSquared));
         }
 
         /// <summary>
@@ -1197,7 +1197,7 @@ public string ToString(
         ///     This is typically the first step in converting from one unit to another.
         /// </summary>
         /// <returns>The value in the base unit representation.</returns>
-        private double AsBaseUnitMeterPerSecondSquared()
+        private double AsBaseUnitMetersPerSecondSquared()
         {
 			if (Unit == AccelerationUnit.MeterPerSecondSquared) { return _value; }
 
diff --git a/UnitsNet/UnitDefinitions/Acceleration.json b/UnitsNet/UnitDefinitions/Acceleration.json
index 9d469729e5..9f76570ce7 100644
--- a/UnitsNet/UnitDefinitions/Acceleration.json
+++ b/UnitsNet/UnitDefinitions/Acceleration.json
@@ -5,7 +5,7 @@
   "Units": [
     {
       "SingularName": "MeterPerSecondSquared",
-      "PluralName": "MeterPerSecondSquared",
+      "PluralName": "MetersPerSecondSquared",
       "FromUnitToBaseFunc": "x",
       "FromBaseToUnitFunc": "x",
       "Prefixes": [ "Nano", "Micro", "Milli", "Centi", "Deci", "Kilo" ],