diff --git a/Common/UnitDefinitions/RotationalStiffness.json b/Common/UnitDefinitions/RotationalStiffness.json
index 304dcd730a..c55bd71fd9 100644
--- a/Common/UnitDefinitions/RotationalStiffness.json
+++ b/Common/UnitDefinitions/RotationalStiffness.json
@@ -20,6 +20,30 @@
           "Abbreviations": [ "N·m/rad", "Nm/rad" ]
         }
       ]
+    },
+    {
+      "SingularName": "PoundForceFootPerDegrees",
+      "PluralName": "PoundForceFeetPerDegrees",
+      "FromUnitToBaseFunc": "x*77.6826",
+      "FromBaseToUnitFunc": "x/77.6826",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "lbf·ft/deg" ]
+        }
+      ]
+    },
+    {
+      "SingularName": "KilopoundForceFootPerDegrees",
+      "PluralName": "KilopoundForceFeetPerDegrees",
+      "FromUnitToBaseFunc": "x*77682.6",
+      "FromBaseToUnitFunc": "x/77682.6",
+      "Localization": [
+        {
+          "Culture": "en-US",
+          "Abbreviations": [ "kipf·ft/°", "kip·ft/°g", "k·ft/°", "kipf·ft/deg", "kip·ft/deg", "k·ft/deg" ]
+        }
+      ]
     }
   ]
 }
diff --git a/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs b/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs
index 953b1cf664..f73aef7d31 100644
--- a/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs
+++ b/UnitsNet.Tests/CustomCode/RotationalStiffnessTests.cs
@@ -28,6 +28,8 @@ namespace UnitsNet.Tests.CustomCode
     public class RotationalStiffnessTests : RotationalStiffnessTestsBase
     {
         protected override double NewtonMetersPerRadianInOneNewtonMeterPerRadian => 1;
+        protected override double PoundForceFeetPerDegreesInOneNewtonMeterPerRadian => 0.0128729;
+        protected override double KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian => 0.0128729e-3;
         protected override double MeganewtonMetersPerRadianInOneNewtonMeterPerRadian => 1e-6;
         protected override double KilonewtonMetersPerRadianInOneNewtonMeterPerRadian => 1e-3;
     }
diff --git a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
index 8951cde1ea..ef93f8c218 100644
--- a/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/IQuantityTests.g.cs
@@ -113,7 +113,7 @@ void Assertion(int expectedValue, Enum expectedUnit, IQuantity quantity)
             Assertion(3, ReactivePowerUnit.VoltampereReactive, Quantity.From(3, ReactivePowerUnit.VoltampereReactive));
             Assertion(3, RotationalAccelerationUnit.RevolutionPerSecondSquared, Quantity.From(3, RotationalAccelerationUnit.RevolutionPerSecondSquared));
             Assertion(3, RotationalSpeedUnit.RevolutionPerSecond, Quantity.From(3, RotationalSpeedUnit.RevolutionPerSecond));
-            Assertion(3, RotationalStiffnessUnit.NewtonMeterPerRadian, Quantity.From(3, RotationalStiffnessUnit.NewtonMeterPerRadian));
+            Assertion(3, RotationalStiffnessUnit.PoundForceFootPerDegrees, Quantity.From(3, RotationalStiffnessUnit.PoundForceFootPerDegrees));
             Assertion(3, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, Quantity.From(3, RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter));
             Assertion(3, SolidAngleUnit.Steradian, Quantity.From(3, SolidAngleUnit.Steradian));
             Assertion(3, SpecificEnergyUnit.WattHourPerKilogram, Quantity.From(3, SpecificEnergyUnit.WattHourPerKilogram));
diff --git a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
index acc0376a89..1186bc4c6c 100644
--- a/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
+++ b/UnitsNet.Tests/GeneratedCode/TestsBase/RotationalStiffnessTestsBase.g.cs
@@ -37,13 +37,17 @@ namespace UnitsNet.Tests
     public abstract partial class RotationalStiffnessTestsBase
     {
         protected abstract double KilonewtonMetersPerRadianInOneNewtonMeterPerRadian { get; }
+        protected abstract double KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian { get; }
         protected abstract double MeganewtonMetersPerRadianInOneNewtonMeterPerRadian { get; }
         protected abstract double NewtonMetersPerRadianInOneNewtonMeterPerRadian { get; }
+        protected abstract double PoundForceFeetPerDegreesInOneNewtonMeterPerRadian { get; }
 
 // ReSharper disable VirtualMemberNeverOverriden.Global
         protected virtual double KilonewtonMetersPerRadianTolerance { get { return 1e-5; } }
+        protected virtual double KilopoundForceFeetPerDegreesTolerance { get { return 1e-5; } }
         protected virtual double MeganewtonMetersPerRadianTolerance { get { return 1e-5; } }
         protected virtual double NewtonMetersPerRadianTolerance { get { return 1e-5; } }
+        protected virtual double PoundForceFeetPerDegreesTolerance { get { return 1e-5; } }
 // ReSharper restore VirtualMemberNeverOverriden.Global
 
         [Fact]
@@ -106,8 +110,10 @@ public void NewtonMeterPerRadianToRotationalStiffnessUnits()
         {
             RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
             AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.KilonewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian, newtonmeterperradian.KilopoundForceFeetPerDegrees, KilopoundForceFeetPerDegreesTolerance);
             AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
             AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(PoundForceFeetPerDegreesInOneNewtonMeterPerRadian, newtonmeterperradian.PoundForceFeetPerDegrees, PoundForceFeetPerDegreesTolerance);
         }
 
         [Fact]
@@ -117,13 +123,21 @@ public void From_ValueAndUnit_ReturnsQuantityWithSameValueAndUnit()
             AssertEx.EqualTolerance(1, quantity00.KilonewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.KilonewtonMeterPerRadian, quantity00.Unit);
 
-            var quantity01 = RotationalStiffness.From(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
-            AssertEx.EqualTolerance(1, quantity01.MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
-            Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerRadian, quantity01.Unit);
+            var quantity01 = RotationalStiffness.From(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+            AssertEx.EqualTolerance(1, quantity01.KilopoundForceFeetPerDegrees, KilopoundForceFeetPerDegreesTolerance);
+            Assert.Equal(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, quantity01.Unit);
 
-            var quantity02 = RotationalStiffness.From(1, RotationalStiffnessUnit.NewtonMeterPerRadian);
-            AssertEx.EqualTolerance(1, quantity02.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
-            Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerRadian, quantity02.Unit);
+            var quantity02 = RotationalStiffness.From(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian);
+            AssertEx.EqualTolerance(1, quantity02.MeganewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
+            Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerRadian, quantity02.Unit);
+
+            var quantity03 = RotationalStiffness.From(1, RotationalStiffnessUnit.NewtonMeterPerRadian);
+            AssertEx.EqualTolerance(1, quantity03.NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerRadian, quantity03.Unit);
+
+            var quantity04 = RotationalStiffness.From(1, RotationalStiffnessUnit.PoundForceFootPerDegrees);
+            AssertEx.EqualTolerance(1, quantity04.PoundForceFeetPerDegrees, PoundForceFeetPerDegreesTolerance);
+            Assert.Equal(RotationalStiffnessUnit.PoundForceFootPerDegrees, quantity04.Unit);
 
         }
 
@@ -145,8 +159,10 @@ public void As()
         {
             var newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
             AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.KilonewtonMeterPerRadian), KilonewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees), KilopoundForceFeetPerDegreesTolerance);
             AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.MeganewtonMeterPerRadian), MeganewtonMetersPerRadianTolerance);
             AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.NewtonMeterPerRadian), NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(PoundForceFeetPerDegreesInOneNewtonMeterPerRadian, newtonmeterperradian.As(RotationalStiffnessUnit.PoundForceFootPerDegrees), PoundForceFeetPerDegreesTolerance);
         }
 
         [Fact]
@@ -158,6 +174,10 @@ public void ToUnit()
             AssertEx.EqualTolerance(KilonewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)kilonewtonmeterperradianQuantity.Value, KilonewtonMetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.KilonewtonMeterPerRadian, kilonewtonmeterperradianQuantity.Unit);
 
+            var kilopoundforcefootperdegreesQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+            AssertEx.EqualTolerance(KilopoundForceFeetPerDegreesInOneNewtonMeterPerRadian, (double)kilopoundforcefootperdegreesQuantity.Value, KilopoundForceFeetPerDegreesTolerance);
+            Assert.Equal(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, kilopoundforcefootperdegreesQuantity.Unit);
+
             var meganewtonmeterperradianQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian);
             AssertEx.EqualTolerance(MeganewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)meganewtonmeterperradianQuantity.Value, MeganewtonMetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.MeganewtonMeterPerRadian, meganewtonmeterperradianQuantity.Unit);
@@ -165,6 +185,10 @@ public void ToUnit()
             var newtonmeterperradianQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.NewtonMeterPerRadian);
             AssertEx.EqualTolerance(NewtonMetersPerRadianInOneNewtonMeterPerRadian, (double)newtonmeterperradianQuantity.Value, NewtonMetersPerRadianTolerance);
             Assert.Equal(RotationalStiffnessUnit.NewtonMeterPerRadian, newtonmeterperradianQuantity.Unit);
+
+            var poundforcefootperdegreesQuantity = newtonmeterperradian.ToUnit(RotationalStiffnessUnit.PoundForceFootPerDegrees);
+            AssertEx.EqualTolerance(PoundForceFeetPerDegreesInOneNewtonMeterPerRadian, (double)poundforcefootperdegreesQuantity.Value, PoundForceFeetPerDegreesTolerance);
+            Assert.Equal(RotationalStiffnessUnit.PoundForceFootPerDegrees, poundforcefootperdegreesQuantity.Unit);
         }
 
         [Fact]
@@ -172,8 +196,10 @@ public void ConversionRoundTrip()
         {
             RotationalStiffness newtonmeterperradian = RotationalStiffness.FromNewtonMetersPerRadian(1);
             AssertEx.EqualTolerance(1, RotationalStiffness.FromKilonewtonMetersPerRadian(newtonmeterperradian.KilonewtonMetersPerRadian).NewtonMetersPerRadian, KilonewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness.FromKilopoundForceFeetPerDegrees(newtonmeterperradian.KilopoundForceFeetPerDegrees).NewtonMetersPerRadian, KilopoundForceFeetPerDegreesTolerance);
             AssertEx.EqualTolerance(1, RotationalStiffness.FromMeganewtonMetersPerRadian(newtonmeterperradian.MeganewtonMetersPerRadian).NewtonMetersPerRadian, MeganewtonMetersPerRadianTolerance);
             AssertEx.EqualTolerance(1, RotationalStiffness.FromNewtonMetersPerRadian(newtonmeterperradian.NewtonMetersPerRadian).NewtonMetersPerRadian, NewtonMetersPerRadianTolerance);
+            AssertEx.EqualTolerance(1, RotationalStiffness.FromPoundForceFeetPerDegrees(newtonmeterperradian.PoundForceFeetPerDegrees).NewtonMetersPerRadian, PoundForceFeetPerDegreesTolerance);
         }
 
         [Fact]
@@ -314,8 +340,10 @@ public void ToString_ReturnsValueAndUnitAbbreviationInCurrentCulture()
             Thread.CurrentThread.CurrentUICulture = CultureInfo.GetCultureInfo("en-US");
             try {
                 Assert.Equal("1 kN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian).ToString());
+                Assert.Equal("1 kipf·ft/°", new RotationalStiffness(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees).ToString());
                 Assert.Equal("1 MN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian).ToString());
                 Assert.Equal("1 N·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString());
+                Assert.Equal("1 lbf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.PoundForceFootPerDegrees).ToString());
             }
             finally
             {
@@ -330,8 +358,10 @@ public void ToString_WithSwedishCulture_ReturnsUnitAbbreviationForEnglishCulture
             var swedishCulture = CultureInfo.GetCultureInfo("sv-SE");
 
             Assert.Equal("1 kN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.KilonewtonMeterPerRadian).ToString(swedishCulture));
+            Assert.Equal("1 kipf·ft/°", new RotationalStiffness(1, RotationalStiffnessUnit.KilopoundForceFootPerDegrees).ToString(swedishCulture));
             Assert.Equal("1 MN·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.MeganewtonMeterPerRadian).ToString(swedishCulture));
             Assert.Equal("1 N·m/rad", new RotationalStiffness(1, RotationalStiffnessUnit.NewtonMeterPerRadian).ToString(swedishCulture));
+            Assert.Equal("1 lbf·ft/deg", new RotationalStiffness(1, RotationalStiffnessUnit.PoundForceFootPerDegrees).ToString(swedishCulture));
         }
 
         [Fact]
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs
index bb1ac04874..4fcc2518f9 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -160,6 +160,11 @@ private RotationalStiffness(double value, RotationalStiffnessUnit unit)
         /// </summary>
         public double KilonewtonMetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMeterPerRadian);
 
+        /// <summary>
+        ///     Get RotationalStiffness in KilopoundForceFeetPerDegrees.
+        /// </summary>
+        public double KilopoundForceFeetPerDegrees => As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+
         /// <summary>
         ///     Get RotationalStiffness in MeganewtonMetersPerRadian.
         /// </summary>
@@ -170,6 +175,11 @@ private RotationalStiffness(double value, RotationalStiffnessUnit unit)
         /// </summary>
         public double NewtonMetersPerRadian => As(RotationalStiffnessUnit.NewtonMeterPerRadian);
 
+        /// <summary>
+        ///     Get RotationalStiffness in PoundForceFeetPerDegrees.
+        /// </summary>
+        public double PoundForceFeetPerDegrees => As(RotationalStiffnessUnit.PoundForceFootPerDegrees);
+
         #endregion
 
         #region Static Methods
@@ -211,6 +221,16 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(double kilonewto
             return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
         }
         /// <summary>
+        ///     Get RotationalStiffness from KilopoundForceFeetPerDegrees.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(double kilopoundforcefeetperdegrees)
+        {
+            double value = (double) kilopoundforcefeetperdegrees;
+            return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+        }
+        /// <summary>
         ///     Get RotationalStiffness from MeganewtonMetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
@@ -230,6 +250,16 @@ public static RotationalStiffness FromNewtonMetersPerRadian(double newtonmetersp
             double value = (double) newtonmetersperradian;
             return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian);
         }
+        /// <summary>
+        ///     Get RotationalStiffness from PoundForceFeetPerDegrees.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        [Windows.Foundation.Metadata.DefaultOverload]
+        public static RotationalStiffness FromPoundForceFeetPerDegrees(double poundforcefeetperdegrees)
+        {
+            double value = (double) poundforcefeetperdegrees;
+            return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees);
+        }
 
         /// <summary>
         ///     Dynamically convert from value and unit enum <see cref="RotationalStiffnessUnit" /> to <see cref="RotationalStiffness" />.
@@ -522,8 +552,10 @@ private double AsBaseUnit()
             switch(Unit)
             {
                 case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d;
+                case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return _value*77682.6;
                 case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d;
                 case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value;
+                case RotationalStiffnessUnit.PoundForceFootPerDegrees: return _value*77.6826;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -539,8 +571,10 @@ private double AsBaseNumericType(RotationalStiffnessUnit unit)
             switch(unit)
             {
                 case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (baseUnitValue) / 1e3d;
+                case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return baseUnitValue/77682.6;
                 case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (baseUnitValue) / 1e6d;
                 case RotationalStiffnessUnit.NewtonMeterPerRadian: return baseUnitValue;
+                case RotationalStiffnessUnit.PoundForceFootPerDegrees: return baseUnitValue/77.6826;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
             }
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
index c69a6aad28..e6d11ff8d5 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/UnitAbbreviationsCache.g.cs
@@ -997,8 +997,10 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin
                 ("en-US", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"r/s"}),
                 ("ru-RU", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"об/с"}),
                 ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilonewtonMeterPerRadian, new string[]{"kN·m/rad", "kNm/rad"}),
+                ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilopoundForceFootPerDegrees, new string[]{"kipf·ft/°", "kip·ft/°g", "k·ft/°", "kipf·ft/deg", "kip·ft/deg", "k·ft/deg"}),
                 ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.MeganewtonMeterPerRadian, new string[]{"MN·m/rad", "MNm/rad"}),
                 ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.NewtonMeterPerRadian, new string[]{"N·m/rad", "Nm/rad"}),
+                ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.PoundForceFootPerDegrees, new string[]{"lbf·ft/deg"}),
                 ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, new string[]{"kN·m/rad/m", "kNm/rad/m"}),
                 ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, new string[]{"MN·m/rad/m", "MNm/rad/m"}),
                 ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, new string[]{"N·m/rad/m", "Nm/rad/m"}),
diff --git a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RotationalStiffnessUnit.g.cs b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RotationalStiffnessUnit.g.cs
index a21f80ea73..dc84d5ae4b 100644
--- a/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RotationalStiffnessUnit.g.cs
+++ b/UnitsNet.WindowsRuntimeComponent/GeneratedCode/Units/RotationalStiffnessUnit.g.cs
@@ -27,8 +27,10 @@ public enum RotationalStiffnessUnit
     {
         Undefined = 0,
         KilonewtonMeterPerRadian,
+        KilopoundForceFootPerDegrees,
         MeganewtonMeterPerRadian,
         NewtonMeterPerRadian,
+        PoundForceFootPerDegrees,
     }
 
     #pragma warning restore 1591
diff --git a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
index 8f9e30e94c..d61ec8c16a 100644
--- a/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
+++ b/UnitsNet/GeneratedCode/Quantities/RotationalStiffness.g.cs
@@ -51,8 +51,10 @@ static RotationalStiffness()
             Info = new QuantityInfo<RotationalStiffnessUnit>(QuantityType.RotationalStiffness,
                 new UnitInfo<RotationalStiffnessUnit>[] {
                     new UnitInfo<RotationalStiffnessUnit>(RotationalStiffnessUnit.KilonewtonMeterPerRadian, BaseUnits.Undefined),
+                    new UnitInfo<RotationalStiffnessUnit>(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, BaseUnits.Undefined),
                     new UnitInfo<RotationalStiffnessUnit>(RotationalStiffnessUnit.MeganewtonMeterPerRadian, BaseUnits.Undefined),
                     new UnitInfo<RotationalStiffnessUnit>(RotationalStiffnessUnit.NewtonMeterPerRadian, BaseUnits.Undefined),
+                    new UnitInfo<RotationalStiffnessUnit>(RotationalStiffnessUnit.PoundForceFootPerDegrees, BaseUnits.Undefined),
                 },
                 BaseUnit, Zero, BaseDimensions);
         }
@@ -170,6 +172,11 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         /// </summary>
         public double KilonewtonMetersPerRadian => As(RotationalStiffnessUnit.KilonewtonMeterPerRadian);
 
+        /// <summary>
+        ///     Get RotationalStiffness in KilopoundForceFeetPerDegrees.
+        /// </summary>
+        public double KilopoundForceFeetPerDegrees => As(RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+
         /// <summary>
         ///     Get RotationalStiffness in MeganewtonMetersPerRadian.
         /// </summary>
@@ -180,6 +187,11 @@ public RotationalStiffness(double value, UnitSystem unitSystem)
         /// </summary>
         public double NewtonMetersPerRadian => As(RotationalStiffnessUnit.NewtonMeterPerRadian);
 
+        /// <summary>
+        ///     Get RotationalStiffness in PoundForceFeetPerDegrees.
+        /// </summary>
+        public double PoundForceFeetPerDegrees => As(RotationalStiffnessUnit.PoundForceFootPerDegrees);
+
         #endregion
 
         #region Static Methods
@@ -219,6 +231,15 @@ public static RotationalStiffness FromKilonewtonMetersPerRadian(QuantityValue ki
             return new RotationalStiffness(value, RotationalStiffnessUnit.KilonewtonMeterPerRadian);
         }
         /// <summary>
+        ///     Get RotationalStiffness from KilopoundForceFeetPerDegrees.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static RotationalStiffness FromKilopoundForceFeetPerDegrees(QuantityValue kilopoundforcefeetperdegrees)
+        {
+            double value = (double) kilopoundforcefeetperdegrees;
+            return new RotationalStiffness(value, RotationalStiffnessUnit.KilopoundForceFootPerDegrees);
+        }
+        /// <summary>
         ///     Get RotationalStiffness from MeganewtonMetersPerRadian.
         /// </summary>
         /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
@@ -236,6 +257,15 @@ public static RotationalStiffness FromNewtonMetersPerRadian(QuantityValue newton
             double value = (double) newtonmetersperradian;
             return new RotationalStiffness(value, RotationalStiffnessUnit.NewtonMeterPerRadian);
         }
+        /// <summary>
+        ///     Get RotationalStiffness from PoundForceFeetPerDegrees.
+        /// </summary>
+        /// <exception cref="ArgumentException">If value is NaN or Infinity.</exception>
+        public static RotationalStiffness FromPoundForceFeetPerDegrees(QuantityValue poundforcefeetperdegrees)
+        {
+            double value = (double) poundforcefeetperdegrees;
+            return new RotationalStiffness(value, RotationalStiffnessUnit.PoundForceFootPerDegrees);
+        }
 
         /// <summary>
         ///     Dynamically convert from value and unit enum <see cref="RotationalStiffnessUnit" /> to <see cref="RotationalStiffness" />.
@@ -666,8 +696,10 @@ private double GetValueInBaseUnit()
             switch(Unit)
             {
                 case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (_value) * 1e3d;
+                case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return _value*77682.6;
                 case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (_value) * 1e6d;
                 case RotationalStiffnessUnit.NewtonMeterPerRadian: return _value;
+                case RotationalStiffnessUnit.PoundForceFootPerDegrees: return _value*77.6826;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to base units.");
             }
@@ -694,8 +726,10 @@ private double GetValueAs(RotationalStiffnessUnit unit)
             switch(unit)
             {
                 case RotationalStiffnessUnit.KilonewtonMeterPerRadian: return (baseUnitValue) / 1e3d;
+                case RotationalStiffnessUnit.KilopoundForceFootPerDegrees: return baseUnitValue/77682.6;
                 case RotationalStiffnessUnit.MeganewtonMeterPerRadian: return (baseUnitValue) / 1e6d;
                 case RotationalStiffnessUnit.NewtonMeterPerRadian: return baseUnitValue;
+                case RotationalStiffnessUnit.PoundForceFootPerDegrees: return baseUnitValue/77.6826;
                 default:
                     throw new NotImplementedException($"Can not convert {Unit} to {unit}.");
             }
diff --git a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
index efb2b4eba8..bb3ef4ae62 100644
--- a/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
+++ b/UnitsNet/GeneratedCode/UnitAbbreviationsCache.g.cs
@@ -997,8 +997,10 @@ private static readonly (string CultureName, Type UnitType, int UnitValue, strin
                 ("en-US", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"r/s"}),
                 ("ru-RU", typeof(RotationalSpeedUnit), (int)RotationalSpeedUnit.RevolutionPerSecond, new string[]{"об/с"}),
                 ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilonewtonMeterPerRadian, new string[]{"kN·m/rad", "kNm/rad"}),
+                ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.KilopoundForceFootPerDegrees, new string[]{"kipf·ft/°", "kip·ft/°g", "k·ft/°", "kipf·ft/deg", "kip·ft/deg", "k·ft/deg"}),
                 ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.MeganewtonMeterPerRadian, new string[]{"MN·m/rad", "MNm/rad"}),
                 ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.NewtonMeterPerRadian, new string[]{"N·m/rad", "Nm/rad"}),
+                ("en-US", typeof(RotationalStiffnessUnit), (int)RotationalStiffnessUnit.PoundForceFootPerDegrees, new string[]{"lbf·ft/deg"}),
                 ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, new string[]{"kN·m/rad/m", "kNm/rad/m"}),
                 ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, new string[]{"MN·m/rad/m", "MNm/rad/m"}),
                 ("en-US", typeof(RotationalStiffnessPerLengthUnit), (int)RotationalStiffnessPerLengthUnit.NewtonMeterPerRadianPerMeter, new string[]{"N·m/rad/m", "Nm/rad/m"}),
diff --git a/UnitsNet/GeneratedCode/UnitConverter.g.cs b/UnitsNet/GeneratedCode/UnitConverter.g.cs
index 217f59c0f4..9581a19f6d 100644
--- a/UnitsNet/GeneratedCode/UnitConverter.g.cs
+++ b/UnitsNet/GeneratedCode/UnitConverter.g.cs
@@ -1549,9 +1549,13 @@ public static void RegisterDefaultConversions(UnitConverter unitConverter)
             unitConverter.SetConversionFunction<RotationalSpeed>(RotationalSpeedUnit.RevolutionPerSecond, RotationalSpeed.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilonewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.KilonewtonMeterPerRadian));
             unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilonewtonMeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
+            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.KilopoundForceFootPerDegrees, q => q.ToUnit(RotationalStiffnessUnit.KilopoundForceFootPerDegrees));
+            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.KilopoundForceFootPerDegrees, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.MeganewtonMeterPerRadian, q => q.ToUnit(RotationalStiffnessUnit.MeganewtonMeterPerRadian));
             unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.MeganewtonMeterPerRadian, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffness.BaseUnit, q => q);
+            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffness.BaseUnit, RotationalStiffnessUnit.PoundForceFootPerDegrees, q => q.ToUnit(RotationalStiffnessUnit.PoundForceFootPerDegrees));
+            unitConverter.SetConversionFunction<RotationalStiffness>(RotationalStiffnessUnit.PoundForceFootPerDegrees, RotationalStiffness.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter));
             unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLengthUnit.KilonewtonMeterPerRadianPerMeter, RotationalStiffnessPerLength.BaseUnit, q => q.ToBaseUnit());
             unitConverter.SetConversionFunction<RotationalStiffnessPerLength>(RotationalStiffnessPerLength.BaseUnit, RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter, q => q.ToUnit(RotationalStiffnessPerLengthUnit.MeganewtonMeterPerRadianPerMeter));
diff --git a/UnitsNet/GeneratedCode/Units/RotationalStiffnessUnit.g.cs b/UnitsNet/GeneratedCode/Units/RotationalStiffnessUnit.g.cs
index a21f80ea73..dc84d5ae4b 100644
--- a/UnitsNet/GeneratedCode/Units/RotationalStiffnessUnit.g.cs
+++ b/UnitsNet/GeneratedCode/Units/RotationalStiffnessUnit.g.cs
@@ -27,8 +27,10 @@ public enum RotationalStiffnessUnit
     {
         Undefined = 0,
         KilonewtonMeterPerRadian,
+        KilopoundForceFootPerDegrees,
         MeganewtonMeterPerRadian,
         NewtonMeterPerRadian,
+        PoundForceFootPerDegrees,
     }
 
     #pragma warning restore 1591