From 6ef5b857583e14d272e8842c3f048a6f87f89d9d Mon Sep 17 00:00:00 2001
From: sciencewhiz <sciencewhiz@users.noreply.github.com>
Date: Wed, 27 Nov 2024 23:01:26 -0800
Subject: [PATCH] [wpiunits] Restore and deprecate divide (#7438)

It was changed to div in #7387, but 2024 used divide.
---
 .../main/java/Measure-interface.java.jinja    |  72 ++++
 .../wpi/first/units/measure/Acceleration.java | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Angle.java    | 312 ++++++++++++++++
 .../units/measure/AngularAcceleration.java    | 312 ++++++++++++++++
 .../first/units/measure/AngularMomentum.java  | 312 ++++++++++++++++
 .../first/units/measure/AngularVelocity.java  | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Current.java  | 312 ++++++++++++++++
 .../first/units/measure/Dimensionless.java    | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Distance.java | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Energy.java   | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Force.java    | 312 ++++++++++++++++
 .../wpi/first/units/measure/Frequency.java    | 312 ++++++++++++++++
 .../units/measure/LinearAcceleration.java     | 312 ++++++++++++++++
 .../first/units/measure/LinearMomentum.java   | 312 ++++++++++++++++
 .../first/units/measure/LinearVelocity.java   | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Mass.java     | 312 ++++++++++++++++
 .../first/units/measure/MomentOfInertia.java  | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Mult.java     | 312 ++++++++++++++++
 .../java/edu/wpi/first/units/measure/Per.java | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Power.java    | 312 ++++++++++++++++
 .../wpi/first/units/measure/Resistance.java   | 312 ++++++++++++++++
 .../wpi/first/units/measure/Temperature.java  | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Time.java     | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Torque.java   | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Velocity.java | 312 ++++++++++++++++
 .../edu/wpi/first/units/measure/Voltage.java  | 312 ++++++++++++++++
 .../java/edu/wpi/first/units/Measure.java     | 337 +++++++++++++++++-
 27 files changed, 8208 insertions(+), 1 deletion(-)

diff --git a/wpiunits/src/generate/main/java/Measure-interface.java.jinja b/wpiunits/src/generate/main/java/Measure-interface.java.jinja
index 06622b8c6e..b17ab8f166 100644
--- a/wpiunits/src/generate/main/java/Measure-interface.java.jinja
+++ b/wpiunits/src/generate/main/java/Measure-interface.java.jinja
@@ -70,6 +70,18 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
     return ({{ helpers['type_usage'](name) }}) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default {{ helpers['type_usage'](name) }} divide(double divisor) {
+    return ({{ helpers['type_usage'](name) }}) div(divisor);
+  }
+
   @Override
   default {{ config[name]['divide']['Time'] or "Velocity<{}>".format(helpers['mtou'](name)) }} per(TimeUnit period) {
     return div(period.of(1));
@@ -81,6 +93,18 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
     return ({{ helpers['type_usage'](name) }}) {{ config[name]['base_unit'] }}.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default {{ helpers['type_usage'](name) }} divide({{ unit }} divisor) {
+    return ({{ helpers['type_usage'](name) }}) div(divisor);
+  }
+
   @Override
   default {{ helpers['type_usage'](name) }} times({{ unit }} multiplier) {
     return ({{ helpers['type_usage'](name) }}) {{ config[name]['base_unit'] }}.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -106,21 +130,69 @@ public interface {{ helpers['type_decl'](name) }} extends Measure<{{ helpers['mt
   default {{ config[name]['divide'][unit] }} div({{ unit }} divisor) {
     return {{ config[config[name]['divide'][unit]]['base_unit'] }}.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
+
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default {{ config[name]['divide'][unit] }} divide({{ unit }} divisor) {
+    return div(divisor);
+  }
 {% elif unit == "Time" %}
   @Override
   default Velocity<{{ helpers['mtou'](name) }}> div({{ unit }} divisor) {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
+
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<{{ helpers['mtou'](name) }}> divide({{ unit }} divisor) {
+    return div(divisor);
+  }
 {% elif unit == name %}
   @Override
   default Dimensionless div({{ unit }} divisor) {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
+
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide({{ unit }} divisor) {
+    return div(divisor);
+  }
 {% else %}
   @Override
   default Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> div({{ unit }} divisor) {
     return (Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}>) Measure.super.div(divisor);
   }
+
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<{{ helpers['mtou'](name) }}, {{ helpers['mtou'](unit) }}> divide({{ unit }} divisor) {
+    return div(divisor);
+  }
 {% endif -%}
 {% endif -%}
 {% endfor -%}
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java
index 6db6eaba55..97da4cdeed 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Acceleration.java
@@ -70,6 +70,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Acceleration<D>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Acceleration<D> divide(double divisor) {
+    return (Acceleration<D>) div(divisor);
+  }
+
   @Override
   default Velocity<AccelerationUnit<D>> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Acceleration<D> div(Dimensionless divisor) {
     return (Acceleration<D>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Acceleration<D> divide(Dimensionless divisor) {
+    return (Acceleration<D>) div(divisor);
+  }
+
   @Override
   default Acceleration<D> times(Dimensionless multiplier) {
     return (Acceleration<D>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<AccelerationUnit<D>> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AccelerationUnit<D>, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Acceleration<D extends Unit> extends Measure<AccelerationUnit<D
     return (Per<AccelerationUnit<D>, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AccelerationUnit<D>, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java
index baeef70597..061e17ffcf 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Angle.java
@@ -70,6 +70,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Angle) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Angle divide(double divisor) {
+    return (Angle) div(divisor);
+  }
+
   @Override
   default AngularVelocity per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Angle extends Measure<AngleUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Angle div(Dimensionless divisor) {
     return (Angle) Radians.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Angle divide(Dimensionless divisor) {
+    return (Angle) div(divisor);
+  }
+
   @Override
   default Angle times(Dimensionless multiplier) {
     return (Angle) Radians.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularVelocity times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Angle extends Measure<AngleUnit> {
     return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularVelocity divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngleUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Angle extends Measure<AngleUnit> {
     return (Per<AngleUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngleUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java
index cb0f4668a1..63d77a4e3d 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularAcceleration.java
@@ -70,6 +70,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (AngularAcceleration) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularAcceleration divide(double divisor) {
+    return (AngularAcceleration) div(divisor);
+  }
+
   @Override
   default Velocity<AngularAccelerationUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default AngularAcceleration div(Dimensionless divisor) {
     return (AngularAcceleration) RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularAcceleration divide(Dimensionless divisor) {
+    return (AngularAcceleration) div(divisor);
+  }
+
   @Override
   default AngularAcceleration times(Dimensionless multiplier) {
     return (AngularAcceleration) RadiansPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularVelocity divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularVelocity times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<AngularAccelerationUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface AngularAcceleration extends Measure<AngularAccelerationUnit> {
     return (Per<AngularAccelerationUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java
index d769afc56d..46d345b974 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularMomentum.java
@@ -70,6 +70,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (AngularMomentum) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularMomentum divide(double divisor) {
+    return (AngularMomentum) div(divisor);
+  }
+
   @Override
   default Velocity<AngularMomentumUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return KilogramSquareMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default MomentOfInertia divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default AngularMomentum div(Dimensionless divisor) {
     return (AngularMomentum) KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularMomentum divide(Dimensionless divisor) {
+    return (AngularMomentum) div(divisor);
+  }
+
   @Override
   default AngularMomentum times(Dimensionless multiplier) {
     return (AngularMomentum) KilogramMetersSquaredPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<AngularMomentumUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularMomentumUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface AngularMomentum extends Measure<AngularMomentumUnit> {
     return (Per<AngularMomentumUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularMomentumUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java
index c796721ada..cd9e517cf4 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/AngularVelocity.java
@@ -70,6 +70,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (AngularVelocity) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularVelocity divide(double divisor) {
+    return (AngularVelocity) div(divisor);
+  }
+
   @Override
   default AngularAcceleration per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default AngularVelocity div(Dimensionless divisor) {
     return (AngularVelocity) RadiansPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularVelocity divide(Dimensionless divisor) {
+    return (AngularVelocity) div(divisor);
+  }
+
   @Override
   default AngularVelocity times(Dimensionless multiplier) {
     return (AngularVelocity) RadiansPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularAcceleration times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Angle times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return RadiansPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default AngularAcceleration divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
     return (Per<AngularVelocityUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<AngularVelocityUnit, VoltageUnit> times(Voltage multiplier) {
@@ -348,5 +648,17 @@ public interface AngularVelocity extends Measure<AngularVelocityUnit> {
   default Per<AngularVelocityUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<AngularVelocityUnit, VoltageUnit>) Measure.super.div(divisor);
   }
+
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<AngularVelocityUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
 default Frequency asFrequency() { return Hertz.of(baseUnitMagnitude()); }
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java
index 2362f3f677..c90149b70c 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Current.java
@@ -70,6 +70,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Current) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Current divide(double divisor) {
+    return (Current) div(divisor);
+  }
+
   @Override
   default Velocity<CurrentUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Current extends Measure<CurrentUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Current div(Dimensionless divisor) {
     return (Current) Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Current divide(Dimensionless divisor) {
+    return (Current) div(divisor);
+  }
+
   @Override
   default Current times(Dimensionless multiplier) {
     return (Current) Amps.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Voltage times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Current extends Measure<CurrentUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<CurrentUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<CurrentUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Power times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Current extends Measure<CurrentUnit> {
     return (Per<CurrentUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<CurrentUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java
index c0cbe5bd18..53c61f65ea 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Dimensionless.java
@@ -70,6 +70,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Dimensionless) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Dimensionless divide(double divisor) {
+    return (Dimensionless) div(divisor);
+  }
+
   @Override
   default Frequency per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Angle times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularAcceleration times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularMomentum times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularVelocity times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Current times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Dimensionless div(Dimensionless divisor) {
     return (Dimensionless) Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Dimensionless divide(Dimensionless divisor) {
+    return (Dimensionless) div(divisor);
+  }
+
   @Override
   default Dimensionless times(Dimensionless multiplier) {
     return (Dimensionless) Value.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Energy times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Force times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Frequency times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default LinearAcceleration times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default LinearMomentum times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default LinearVelocity times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mass times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default MomentOfInertia times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DimensionlessUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DimensionlessUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Power times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Resistance times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Temperature times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Time times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Frequency divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Torque times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DimensionlessUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Voltage times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Dimensionless extends Measure<DimensionlessUnit> {
     return (Per<DimensionlessUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DimensionlessUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java
index ec639e265f..f339d2b6e7 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Distance.java
@@ -70,6 +70,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Distance) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Distance divide(double divisor) {
+    return (Distance) div(divisor);
+  }
+
   @Override
   default LinearVelocity per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Distance div(Dimensionless divisor) {
     return (Distance) Meters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Distance divide(Dimensionless divisor) {
+    return (Distance) div(divisor);
+  }
+
   @Override
   default Distance times(Dimensionless multiplier) {
     return (Distance) Meters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Torque times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default LinearVelocity times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return Seconds.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Time divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearVelocity divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<DistanceUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Distance extends Measure<DistanceUnit> {
     return (Per<DistanceUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<DistanceUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java
index 7b101081e8..aa0d601b50 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Energy.java
@@ -70,6 +70,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Energy) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Energy divide(double divisor) {
+    return (Energy) div(divisor);
+  }
+
   @Override
   default Power per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Energy div(Dimensionless divisor) {
     return (Energy) Joules.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Energy divide(Dimensionless divisor) {
+    return (Energy) div(divisor);
+  }
+
   @Override
   default Energy times(Dimensionless multiplier) {
     return (Energy) Joules.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Power times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return Watts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Power divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<EnergyUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Energy extends Measure<EnergyUnit> {
     return (Per<EnergyUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<EnergyUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java
index 10b0decfe6..d8f1f7a208 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Force.java
@@ -70,6 +70,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Force) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Force divide(double divisor) {
+    return (Force) div(divisor);
+  }
+
   @Override
   default Velocity<ForceUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Force div(Dimensionless divisor) {
     return (Force) Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Force divide(Dimensionless divisor) {
+    return (Force) div(divisor);
+  }
+
   @Override
   default Force times(Dimensionless multiplier) {
     return (Force) Newtons.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Force extends Measure<ForceUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Force extends Measure<ForceUnit> {
     return Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Mass divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Force extends Measure<ForceUnit> {
     return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearAcceleration divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Force extends Measure<ForceUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<ForceUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ForceUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Force extends Measure<ForceUnit> {
     return (Per<ForceUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ForceUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java
index e553f495fd..5b01153cc9 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Frequency.java
@@ -70,6 +70,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Frequency) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Frequency divide(double divisor) {
+    return (Frequency) div(divisor);
+  }
+
   @Override
   default Velocity<FrequencyUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularVelocity times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularAcceleration times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Frequency div(Dimensionless divisor) {
     return (Frequency) Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Frequency divide(Dimensionless divisor) {
+    return (Frequency) div(divisor);
+  }
+
   @Override
   default Frequency times(Dimensionless multiplier) {
     return (Frequency) Hertz.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default LinearAcceleration times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Dimensionless times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<FrequencyUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
     return (Per<FrequencyUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<FrequencyUnit, VoltageUnit> times(Voltage multiplier) {
@@ -348,6 +648,18 @@ public interface Frequency extends Measure<FrequencyUnit> {
   default Per<FrequencyUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<FrequencyUnit, VoltageUnit>) Measure.super.div(divisor);
   }
+
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<FrequencyUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
 /** Converts this frequency to the time period between cycles. */
 default Time asPeriod() { return Seconds.of(1 / baseUnitMagnitude()); }
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java
index bbbeb8f793..5224e53274 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearAcceleration.java
@@ -70,6 +70,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (LinearAcceleration) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearAcceleration divide(double divisor) {
+    return (LinearAcceleration) div(divisor);
+  }
+
   @Override
   default Velocity<LinearAccelerationUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default LinearAcceleration div(Dimensionless divisor) {
     return (LinearAcceleration) MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearAcceleration divide(Dimensionless divisor) {
+    return (LinearAcceleration) div(divisor);
+  }
+
   @Override
   default LinearAcceleration times(Dimensionless multiplier) {
     return (LinearAcceleration) MetersPerSecondPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearVelocity divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default LinearVelocity times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<LinearAccelerationUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearAccelerationUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface LinearAcceleration extends Measure<LinearAccelerationUnit> {
     return (Per<LinearAccelerationUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearAccelerationUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java
index bf0cff3d72..b8e0789520 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearMomentum.java
@@ -70,6 +70,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (LinearMomentum) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearMomentum divide(double divisor) {
+    return (LinearMomentum) div(divisor);
+  }
+
   @Override
   default Force per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default LinearMomentum div(Dimensionless divisor) {
     return (LinearMomentum) KilogramMetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearMomentum divide(Dimensionless divisor) {
+    return (LinearMomentum) div(divisor);
+  }
+
   @Override
   default LinearMomentum times(Dimensionless multiplier) {
     return (LinearMomentum) KilogramMetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Force times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Mass divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearVelocity divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Force divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearMomentumUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface LinearMomentum extends Measure<LinearMomentumUnit> {
     return (Per<LinearMomentumUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearMomentumUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java
index 3b85ef7789..9c4570f9c3 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/LinearVelocity.java
@@ -70,6 +70,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (LinearVelocity) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearVelocity divide(double divisor) {
+    return (LinearVelocity) div(divisor);
+  }
+
   @Override
   default LinearAcceleration per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default LinearVelocity div(Dimensionless divisor) {
     return (LinearVelocity) MetersPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearVelocity divide(Dimensionless divisor) {
+    return (LinearVelocity) div(divisor);
+  }
+
   @Override
   default LinearVelocity times(Dimensionless multiplier) {
     return (LinearVelocity) MetersPerSecond.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default LinearAcceleration times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Distance times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return MetersPerSecondPerSecond.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default LinearAcceleration divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<LinearVelocityUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface LinearVelocity extends Measure<LinearVelocityUnit> {
     return (Per<LinearVelocityUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<LinearVelocityUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java
index 2c1c138ef1..d3ca9bf88f 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mass.java
@@ -70,6 +70,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Mass) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Mass divide(double divisor) {
+    return (Mass) div(divisor);
+  }
+
   @Override
   default Velocity<MassUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Mass div(Dimensionless divisor) {
     return (Mass) Kilograms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Mass divide(Dimensionless divisor) {
+    return (Mass) div(divisor);
+  }
+
   @Override
   default Mass times(Dimensionless multiplier) {
     return (Mass) Kilograms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Force times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Mass extends Measure<MassUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Mass extends Measure<MassUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<MassUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MassUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Mass extends Measure<MassUnit> {
     return (Per<MassUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MassUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java
index 8fc6ed9670..3ca532e64d 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/MomentOfInertia.java
@@ -70,6 +70,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (MomentOfInertia) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default MomentOfInertia divide(double divisor) {
+    return (MomentOfInertia) div(divisor);
+  }
+
   @Override
   default Velocity<MomentOfInertiaUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularMomentum times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default MomentOfInertia div(Dimensionless divisor) {
     return (MomentOfInertia) KilogramSquareMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default MomentOfInertia divide(Dimensionless divisor) {
+    return (MomentOfInertia) div(divisor);
+  }
+
   @Override
   default MomentOfInertia times(Dimensionless multiplier) {
     return (MomentOfInertia) KilogramSquareMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<MomentOfInertiaUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MomentOfInertiaUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface MomentOfInertia extends Measure<MomentOfInertiaUnit> {
     return (Per<MomentOfInertiaUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MomentOfInertiaUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java
index 83489d46cf..128207520b 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Mult.java
@@ -70,6 +70,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Mult<A, B>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Mult<A, B> divide(double divisor) {
+    return (Mult<A, B>) div(divisor);
+  }
+
   @Override
   default Velocity<MultUnit<A, B>> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Mult<A, B> div(Dimensionless divisor) {
     return (Mult<A, B>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Mult<A, B> divide(Dimensionless divisor) {
+    return (Mult<A, B>) div(divisor);
+  }
+
   @Override
   default Mult<A, B> times(Dimensionless multiplier) {
     return (Mult<A, B>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<MultUnit<A, B>> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<MultUnit<A, B>, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Mult<A extends Unit, B extends Unit> extends Measure<MultUnit<A
     return (Per<MultUnit<A, B>, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<MultUnit<A, B>, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java
index fa776bee00..e66601c8bf 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Per.java
@@ -70,6 +70,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<Dividend, Divisor>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Per<Dividend, Divisor> divide(double divisor) {
+    return (Per<Dividend, Divisor>) div(divisor);
+  }
+
   @Override
   default Velocity<PerUnit<Dividend, Divisor>> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Per<Dividend, Divisor> div(Dimensionless divisor) {
     return (Per<Dividend, Divisor>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Per<Dividend, Divisor> divide(Dimensionless divisor) {
+    return (Per<Dividend, Divisor>) div(divisor);
+  }
+
   @Override
   default Per<Dividend, Divisor> times(Dimensionless multiplier) {
     return (Per<Dividend, Divisor>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<PerUnit<Dividend, Divisor>> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
     return (Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PerUnit<Dividend, Divisor>, VoltageUnit> times(Voltage multiplier) {
@@ -348,6 +648,18 @@ public interface Per<Dividend extends Unit, Divisor extends Unit> extends Measur
   default Per<PerUnit<Dividend, Divisor>, VoltageUnit> div(Voltage divisor) {
     return (Per<PerUnit<Dividend, Divisor>, VoltageUnit>) Measure.super.div(divisor);
   }
+
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PerUnit<Dividend, Divisor>, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
 default Measure<Dividend> timesDivisor(Measure<? extends Divisor> multiplier) {
   return (Measure<Dividend>) baseUnit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java
index 6cfc1feb40..49a94a77d0 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Power.java
@@ -70,6 +70,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Power) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Power divide(double divisor) {
+    return (Power) div(divisor);
+  }
+
   @Override
   default Velocity<PowerUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Power extends Measure<PowerUnit> {
     return Volts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Voltage divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Power div(Dimensionless divisor) {
     return (Power) Watts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Power divide(Dimensionless divisor) {
+    return (Power) div(divisor);
+  }
+
   @Override
   default Power times(Dimensionless multiplier) {
     return (Power) Watts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Power extends Measure<PowerUnit> {
     return Hertz.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Frequency divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Power extends Measure<PowerUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Energy times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Power extends Measure<PowerUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<PowerUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Power extends Measure<PowerUnit> {
     return (Per<PowerUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<PowerUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<PowerUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Power extends Measure<PowerUnit> {
     return Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Current divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Resistance.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Resistance.java
index 06e0dad2c7..09af163fc0 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Resistance.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Resistance.java
@@ -70,6 +70,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Resistance) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Resistance divide(double divisor) {
+    return (Resistance) div(divisor);
+  }
+
   @Override
   default Velocity<ResistanceUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Voltage times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Resistance div(Dimensionless divisor) {
     return (Resistance) Ohms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Resistance divide(Dimensionless divisor) {
+    return (Resistance) div(divisor);
+  }
+
   @Override
   default Resistance times(Dimensionless multiplier) {
     return (Resistance) Ohms.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<ResistanceUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<ResistanceUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Resistance extends Measure<ResistanceUnit> {
     return (Per<ResistanceUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<ResistanceUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java
index 1ce254265b..fb9a58fe24 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Temperature.java
@@ -70,6 +70,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Temperature) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Temperature divide(double divisor) {
+    return (Temperature) div(divisor);
+  }
+
   @Override
   default Velocity<TemperatureUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Temperature div(Dimensionless divisor) {
     return (Temperature) Kelvin.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Temperature divide(Dimensionless divisor) {
+    return (Temperature) div(divisor);
+  }
+
   @Override
   default Temperature times(Dimensionless multiplier) {
     return (Temperature) Kelvin.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<TemperatureUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TemperatureUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Temperature extends Measure<TemperatureUnit> {
     return (Per<TemperatureUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TemperatureUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java
index f09bf36a3e..bca1ac2877 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Time.java
@@ -70,6 +70,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Time) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Time divide(double divisor) {
+    return (Time) div(divisor);
+  }
+
   @Override
   default Dimensionless per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default AngularVelocity times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Angle times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Time div(Dimensionless divisor) {
     return (Time) Seconds.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Time divide(Dimensionless divisor) {
+    return (Time) div(divisor);
+  }
+
   @Override
   default Time times(Dimensionless multiplier) {
     return (Time) Seconds.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Dimensionless times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default LinearVelocity times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Distance times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Time extends Measure<TimeUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Dimensionless divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Time extends Measure<TimeUnit> {
     return (Per<TimeUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TimeUnit, VoltageUnit> times(Voltage multiplier) {
@@ -348,5 +648,17 @@ public interface Time extends Measure<TimeUnit> {
   default Per<TimeUnit, VoltageUnit> div(Voltage divisor) {
     return (Per<TimeUnit, VoltageUnit>) Measure.super.div(divisor);
   }
+
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TimeUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
 default Frequency asFrequency() { return Hertz.of(1 / baseUnitMagnitude()); }
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java
index 253e70d331..71dfce1b96 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Torque.java
@@ -70,6 +70,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Torque) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Torque divide(double divisor) {
+    return (Torque) div(divisor);
+  }
+
   @Override
   default Velocity<TorqueUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Torque div(Dimensionless divisor) {
     return (Torque) NewtonMeters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Torque divide(Dimensionless divisor) {
+    return (Torque) div(divisor);
+  }
+
   @Override
   default Torque times(Dimensionless multiplier) {
     return (Torque) NewtonMeters.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return Newtons.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Force divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return Meters.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Distance divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<TorqueUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<TorqueUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Torque extends Measure<TorqueUnit> {
     return (Per<TorqueUnit, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<TorqueUnit, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java
index 6c8ece51a6..ec0993f892 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Velocity.java
@@ -70,6 +70,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Velocity<D>) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Velocity<D> divide(double divisor) {
+    return (Velocity<D>) div(divisor);
+  }
+
   @Override
   default Velocity<VelocityUnit<D>> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, CurrentUnit> times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, CurrentUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, CurrentUnit> divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Velocity<D> div(Dimensionless divisor) {
     return (Velocity<D>) unit().of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Velocity<D> divide(Dimensionless divisor) {
+    return (Velocity<D>) div(divisor);
+  }
+
   @Override
   default Velocity<D> times(Dimensionless multiplier) {
     return (Velocity<D>) unit().of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, ResistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, ResistanceUnit> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Measure<D> times(Time multiplier) {
     return (Measure<D>) unit().numerator().ofBaseUnits(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -315,6 +579,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<VelocityUnit<D>> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, TorqueUnit> times(Torque multiplier) {
@@ -326,6 +602,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -337,6 +625,18 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VelocityUnit<D>, VoltageUnit> times(Voltage multiplier) {
@@ -348,4 +648,16 @@ public interface Velocity<D extends Unit> extends Measure<VelocityUnit<D>> {
     return (Per<VelocityUnit<D>, VoltageUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VelocityUnit<D>, VoltageUnit> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java
index 04553eda43..49602db7e0 100644
--- a/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java
+++ b/wpiunits/src/generated/main/java/edu/wpi/first/units/measure/Voltage.java
@@ -70,6 +70,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Voltage) unit().ofBaseUnits(baseUnitMagnitude() / divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Voltage divide(double divisor) {
+    return (Voltage) div(divisor);
+  }
+
   @Override
   default Velocity<VoltageUnit> per(TimeUnit period) {
     return div(period.of(1));
@@ -86,6 +98,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, AccelerationUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, AccelerationUnit<?>> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, AngleUnit> times(Angle multiplier) {
@@ -97,6 +121,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, AngleUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, AngleUnit> divide(Angle divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, AngularAccelerationUnit> times(AngularAcceleration multiplier) {
@@ -108,6 +144,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, AngularAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, AngularAccelerationUnit> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, AngularMomentumUnit> times(AngularMomentum multiplier) {
@@ -119,6 +167,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, AngularMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, AngularMomentumUnit> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, AngularVelocityUnit> times(AngularVelocity multiplier) {
@@ -130,6 +190,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, AngularVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, AngularVelocityUnit> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Power times(Current multiplier) {
@@ -141,11 +213,35 @@ public interface Voltage extends Measure<VoltageUnit> {
     return Ohms.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Resistance divide(Current divisor) {
+    return div(divisor);
+  }
+
   @Override
   default Voltage div(Dimensionless divisor) {
     return (Voltage) Volts.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Voltage divide(Dimensionless divisor) {
+    return (Voltage) div(divisor);
+  }
+
   @Override
   default Voltage times(Dimensionless multiplier) {
     return (Voltage) Volts.of(baseUnitMagnitude() * multiplier.baseUnitMagnitude());
@@ -162,6 +258,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, DistanceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, DistanceUnit> divide(Distance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, EnergyUnit> times(Energy multiplier) {
@@ -173,6 +281,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, EnergyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, EnergyUnit> divide(Energy divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, ForceUnit> times(Force multiplier) {
@@ -184,6 +304,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, ForceUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, ForceUnit> divide(Force divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, FrequencyUnit> times(Frequency multiplier) {
@@ -195,6 +327,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, FrequencyUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, FrequencyUnit> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, LinearAccelerationUnit> times(LinearAcceleration multiplier) {
@@ -206,6 +350,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, LinearAccelerationUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, LinearAccelerationUnit> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, LinearMomentumUnit> times(LinearMomentum multiplier) {
@@ -217,6 +373,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, LinearMomentumUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, LinearMomentumUnit> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, LinearVelocityUnit> times(LinearVelocity multiplier) {
@@ -228,6 +396,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, LinearVelocityUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, LinearVelocityUnit> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, MassUnit> times(Mass multiplier) {
@@ -239,6 +419,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, MassUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, MassUnit> divide(Mass divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, MomentOfInertiaUnit> times(MomentOfInertia multiplier) {
@@ -250,6 +442,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, MomentOfInertiaUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, MomentOfInertiaUnit> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, MultUnit<?, ?>> times(Mult<?, ?> multiplier) {
@@ -261,6 +465,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, MultUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, MultUnit<?, ?>> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, PerUnit<?, ?>> times(Per<?, ?> multiplier) {
@@ -272,6 +488,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, PerUnit<?, ?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, PerUnit<?, ?>> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, PowerUnit> times(Power multiplier) {
@@ -283,6 +511,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, PowerUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, PowerUnit> divide(Power divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, ResistanceUnit> times(Resistance multiplier) {
@@ -294,6 +534,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return Amps.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Override
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  default Current divide(Resistance divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, TemperatureUnit> times(Temperature multiplier) {
@@ -305,6 +557,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, TemperatureUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, TemperatureUnit> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, TimeUnit> times(Time multiplier) {
@@ -316,6 +580,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return VelocityUnit.combine(unit(), divisor.unit()).ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Velocity<VoltageUnit> divide(Time divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, TorqueUnit> times(Torque multiplier) {
@@ -327,6 +603,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, TorqueUnit>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, TorqueUnit> divide(Torque divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, VelocityUnit<?>> times(Velocity<?> multiplier) {
@@ -338,6 +626,18 @@ public interface Voltage extends Measure<VoltageUnit> {
     return (Per<VoltageUnit, VelocityUnit<?>>) Measure.super.div(divisor);
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Per<VoltageUnit, VelocityUnit<?>> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
 
   @Override
   default Mult<VoltageUnit, VoltageUnit> times(Voltage multiplier) {
@@ -349,4 +649,16 @@ public interface Voltage extends Measure<VoltageUnit> {
     return Value.of(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+  * {@inheritDoc}
+  *
+  * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+  */
+  @Deprecated(since = "2025", forRemoval = true)
+  @SuppressWarnings({"deprecation", "removal"})
+  @Override
+  default Dimensionless divide(Voltage divisor) {
+    return div(divisor);
+  }
+
 }
diff --git a/wpiunits/src/main/java/edu/wpi/first/units/Measure.java b/wpiunits/src/main/java/edu/wpi/first/units/Measure.java
index 2745e2d35c..28d6d9614a 100644
--- a/wpiunits/src/main/java/edu/wpi/first/units/Measure.java
+++ b/wpiunits/src/main/java/edu/wpi/first/units/Measure.java
@@ -152,7 +152,7 @@ public interface Measure<U extends Unit> extends Comparable<Measure<U>> {
    * equivalent to -10 Kelvin, and <i>not</i> -10° Celsius.
    *
    * @return a measure equal to zero minus this measure
-   * @deprecated use unaryMinus() instead. This was renamed for consistancy with other WPILib
+   * @deprecated use unaryMinus() instead. This was renamed for consistency with other WPILib
    *     classes like Rotation2d
    */
   @Deprecated(since = "2025", forRemoval = true)
@@ -1021,6 +1021,341 @@ public interface Measure<U extends Unit> extends Comparable<Measure<U>> {
         .ofBaseUnits(baseUnitMagnitude() / divisor.baseUnitMagnitude());
   }
 
+  /**
+   * Divides this measure by a unitless scalar and returns the result.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<U> divide(double divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a dimensionless scalar and returns the result.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<U> divide(Dimensionless divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measurement by another measure and performs some dimensional analysis to reduce
+   * the units.
+   *
+   * @param divisor the unit to divide by
+   * @return the resulting measure
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Measure<?> divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a generic acceleration and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Acceleration<?> divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by an angle and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Angle divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by an angular acceleration and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(AngularAcceleration divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by an angular momentum and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(AngularMomentum divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by an angular velocity and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(AngularVelocity divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by an electric current and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Current divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a distance and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Distance divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by an energy and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Energy divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a force and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Force divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a frequency and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Frequency divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a linear acceleration and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(LinearAcceleration divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a linear momentum and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(LinearMomentum divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a linear velocity and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(LinearVelocity divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a mass and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Mass divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a moment of inertia and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(MomentOfInertia divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a generic multiplication and returns the result in the most appropriate
+   * unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Mult<?, ?> divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a power and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Power divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a generic ratio and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Per<?, ?> divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a temperature and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Temperature divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a time and returns the result in the most appropriate unit. This will
+   * often - but not always - result in a {@link Per} type like {@link LinearVelocity} or {@link
+   * Acceleration}.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Time divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a torque and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Torque divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a generic velocity and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Velocity<?> divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a voltage and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Voltage divisor) {
+    return div(divisor);
+  }
+
+  /**
+   * Divides this measure by a resistance and returns the result in the most appropriate unit.
+   *
+   * @param divisor the measurement to divide by.
+   * @return the division result
+   * @deprecated use div instead. This was renamed for consistency with other languages like Kotlin
+   */
+  @Deprecated(since = "2025", forRemoval = true)
+  default Measure<?> divide(Resistance divisor) {
+    return div(divisor);
+  }
+
   /**
    * Divides this measure by a ratio in terms of this measurement's unit to another unit, returning
    * a measurement in terms of the other unit.