diff --git a/src/builtins/compiled/zoneddatetime.rs b/src/builtins/compiled/zoneddatetime.rs
index f666b88e5..290c74eed 100644
--- a/src/builtins/compiled/zoneddatetime.rs
+++ b/src/builtins/compiled/zoneddatetime.rs
@@ -5,8 +5,8 @@ use crate::provider::TransitionDirection;
 use crate::ZonedDateTime;
 use crate::{
     options::{
-        ArithmeticOverflow, DifferenceSettings, Disambiguation, DisplayCalendar, DisplayOffset,
-        DisplayTimeZone, OffsetDisambiguation, RoundingOptions, ToStringRoundingOptions,
+        DifferenceSettings, Disambiguation, DisplayCalendar, DisplayOffset, DisplayTimeZone,
+        OffsetDisambiguation, Overflow, RoundingOptions, ToStringRoundingOptions,
     },
     Calendar, Duration, PlainTime, TemporalResult, TimeZone,
 };
@@ -69,7 +69,7 @@ impl ZonedDateTime {
     #[inline]
     pub fn from_partial(
         partial: PartialZonedDateTime,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
         disambiguation: Option<Disambiguation>,
         offset_option: Option<OffsetDisambiguation>,
     ) -> TemporalResult<Self> {
@@ -88,7 +88,7 @@ impl ZonedDateTime {
         fields: ZonedDateTimeFields,
         disambiguation: Option<Disambiguation>,
         offset_option: Option<OffsetDisambiguation>,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         self.with_with_provider(
             fields,
@@ -115,11 +115,7 @@ impl ZonedDateTime {
     /// Adds a [`Duration`] to the current `ZonedDateTime`.
     ///
     /// Enable with the `compiled_data` feature flag.
-    pub fn add(
-        &self,
-        duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn add(&self, duration: &Duration, overflow: Option<Overflow>) -> TemporalResult<Self> {
         self.add_with_provider(duration, overflow, &*TZ_PROVIDER)
     }
 
@@ -129,7 +125,7 @@ impl ZonedDateTime {
     pub fn subtract(
         &self,
         duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         self.subtract_with_provider(duration, overflow, &*TZ_PROVIDER)
     }
diff --git a/src/builtins/core/calendar.rs b/src/builtins/core/calendar.rs
index 18ca96c99..b79dd32a1 100644
--- a/src/builtins/core/calendar.rs
+++ b/src/builtins/core/calendar.rs
@@ -8,7 +8,7 @@ use crate::{
         duration::DateDuration, Duration, PlainDate, PlainDateTime, PlainMonthDay, PlainYearMonth,
     },
     iso::IsoDate,
-    options::{ArithmeticOverflow, Unit},
+    options::{Overflow, Unit},
     parsers::parse_allowed_calendar_formats,
     TemporalError, TemporalResult,
 };
@@ -191,7 +191,7 @@ impl Calendar {
     pub fn date_from_fields(
         &self,
         fields: CalendarFields,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<PlainDate> {
         let resolved_fields =
             ResolvedCalendarFields::try_from_fields(self, &fields, overflow, ResolutionType::Date)?;
@@ -227,7 +227,7 @@ impl Calendar {
     pub fn month_day_from_fields(
         &self,
         mut fields: CalendarFields,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<PlainMonthDay> {
         // You are allowed to specify year information, however
         // it is *only* used for resolving the given month/day data.
@@ -283,7 +283,7 @@ impl Calendar {
     pub fn year_month_from_fields(
         &self,
         fields: YearMonthCalendarFields,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<PlainYearMonth> {
         // TODO: add a from_partial_year_month method on ResolvedCalendarFields
         let resolved_fields = ResolvedCalendarFields::try_from_fields(
@@ -324,7 +324,7 @@ impl Calendar {
         &self,
         date: &IsoDate,
         duration: &DateDuration,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<PlainDate> {
         // 1. If calendar is "iso8601", then
         if self.is_iso() {
diff --git a/src/builtins/core/calendar/fields.rs b/src/builtins/core/calendar/fields.rs
index a7bd8c58d..334693aff 100644
--- a/src/builtins/core/calendar/fields.rs
+++ b/src/builtins/core/calendar/fields.rs
@@ -2,8 +2,8 @@ use tinystr::TinyAsciiStr;
 
 use super::types::month_to_month_code;
 use crate::{
-    error::ErrorMessage, options::ArithmeticOverflow, Calendar, MonthCode, PlainDate,
-    PlainDateTime, PlainMonthDay, PlainYearMonth, TemporalError, TemporalResult,
+    error::ErrorMessage, options::Overflow, Calendar, MonthCode, PlainDate, PlainDateTime,
+    PlainMonthDay, PlainYearMonth, TemporalError, TemporalResult,
 };
 use core::ops::Range;
 
@@ -286,7 +286,7 @@ impl YearMonthCalendarFields {
 #[macro_export]
 macro_rules! impl_with_fallback_method {
     ($method_name:ident, $fields_type:ident, ( $(with_day: $day:ident)? ) $component_type:ty) => {
-        pub(crate) fn $method_name(&self, fallback: &$component_type, calendar: icu_calendar::AnyCalendarKind, overflow: ArithmeticOverflow) -> TemporalResult<Self> {
+        pub(crate) fn $method_name(&self, fallback: &$component_type, calendar: icu_calendar::AnyCalendarKind, overflow: Overflow) -> TemporalResult<Self> {
             let keys_to_ignore = self.field_keys_to_ignore(calendar);
             let mut era = self.era;
 
@@ -315,7 +315,7 @@ macro_rules! impl_with_fallback_method {
             let (month, month_code) = match (self.month, self.month_code) {
                 (Some(month), Some(mc)) => (Some(month), Some(mc)),
                 (Some(month), None) => {
-                    let month_maybe_clamped = if overflow == ArithmeticOverflow::Constrain {
+                    let month_maybe_clamped = if overflow == Overflow::Constrain {
                         // TODO (manishearth) this should be managed by ICU4X
                         // https://github.com/unicode-org/icu4x/issues/6790
                         month.clamp(1, 12)
diff --git a/src/builtins/core/calendar/types.rs b/src/builtins/core/calendar/types.rs
index 5b7d77475..fa35cb037 100644
--- a/src/builtins/core/calendar/types.rs
+++ b/src/builtins/core/calendar/types.rs
@@ -5,7 +5,7 @@ use tinystr::TinyAsciiStr;
 
 use crate::fields::CalendarFields;
 use crate::iso::{constrain_iso_day, is_valid_iso_day};
-use crate::options::ArithmeticOverflow;
+use crate::options::Overflow;
 use crate::Calendar;
 use crate::{TemporalError, TemporalResult};
 use icu_calendar::AnyCalendarKind;
@@ -32,7 +32,7 @@ impl ResolvedCalendarFields {
     pub fn try_from_fields(
         calendar: &Calendar,
         fields: &CalendarFields,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
         resolve_type: ResolutionType,
     ) -> TemporalResult<Self> {
         fields.check_year_in_safe_arithmetical_range()?;
@@ -46,7 +46,7 @@ impl ResolvedCalendarFields {
                 month_code,
                 calendar,
             )?;
-            let day = if overflow == ArithmeticOverflow::Constrain {
+            let day = if overflow == Overflow::Constrain {
                 constrain_iso_day(era_year.year, month_code.to_month_integer(), day)
             } else {
                 if !is_valid_iso_day(era_year.year, month_code.to_month_integer(), day) {
@@ -572,14 +572,14 @@ const fn ascii_digit_to_int(ascii_digit: u8) -> u8 {
 fn resolve_iso_month(
     calendar: &Calendar,
     fields: &CalendarFields,
-    overflow: ArithmeticOverflow,
+    overflow: Overflow,
 ) -> TemporalResult<MonthCode> {
     let month_code = match (fields.month_code, fields.month) {
         (None, None) => {
             return Err(TemporalError::r#type().with_message("Month or monthCode must be provided."))
         }
         (None, Some(month)) => {
-            if overflow == ArithmeticOverflow::Constrain {
+            if overflow == Overflow::Constrain {
                 return month_to_month_code(month.clamp(1, 12));
             }
             if !(1..=12).contains(&month) {
@@ -613,7 +613,7 @@ mod tests {
             calendar::{types::ResolutionType, CalendarFields},
             core::{calendar::Calendar, PartialDate, PlainDate},
         },
-        options::ArithmeticOverflow,
+        options::Overflow,
     };
 
     use super::{month_to_month_code, MonthCode, ResolvedCalendarFields};
@@ -665,9 +665,9 @@ mod tests {
 
         let cal = Calendar::default();
 
-        let err = cal.date_from_fields(bad_fields.clone(), ArithmeticOverflow::Reject);
+        let err = cal.date_from_fields(bad_fields.clone(), Overflow::Reject);
         assert!(err.is_err());
-        let result = cal.date_from_fields(bad_fields, ArithmeticOverflow::Constrain);
+        let result = cal.date_from_fields(bad_fields, Overflow::Constrain);
         assert!(result.is_ok());
     }
 
@@ -698,8 +698,7 @@ mod tests {
                 };
 
                 let plain_date =
-                    PlainDate::from_partial(partial, Some(ArithmeticOverflow::Constrain))
-                        .expect(&expect_str);
+                    PlainDate::from_partial(partial, Some(Overflow::Constrain)).expect(&expect_str);
 
                 assert_eq!(
                     plain_date.year(),
@@ -710,7 +709,7 @@ mod tests {
 
                 // Get the full partial date.
                 let full_partial = CalendarFields::default()
-                    .with_fallback_date(&plain_date, *cal, ArithmeticOverflow::Constrain)
+                    .with_fallback_date(&plain_date, *cal, Overflow::Constrain)
                     .expect(&expect_str);
 
                 let era_year = super::EraYear::try_from_fields(
@@ -748,7 +747,7 @@ mod tests {
         let err = ResolvedCalendarFields::try_from_fields(
             &Calendar::ISO,
             &bad_fields,
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
             ResolutionType::Date,
         );
         assert!(err.is_err());
@@ -765,7 +764,7 @@ mod tests {
         let err = ResolvedCalendarFields::try_from_fields(
             &Calendar::ISO,
             &bad_fields,
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
             ResolutionType::Date,
         );
         assert!(err.is_err());
@@ -774,7 +773,7 @@ mod tests {
         let err = ResolvedCalendarFields::try_from_fields(
             &Calendar::ISO,
             &bad_fields,
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
             ResolutionType::Date,
         );
         assert!(err.is_err());
diff --git a/src/builtins/core/date.rs b/src/builtins/core/date.rs
index d99ac3046..51c6e6ce0 100644
--- a/src/builtins/core/date.rs
+++ b/src/builtins/core/date.rs
@@ -11,8 +11,8 @@ use crate::{
     },
     iso::{IsoDate, IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, Disambiguation,
-        DisplayCalendar, ResolvedRoundingOptions, Unit, UnitGroup,
+        DifferenceOperation, DifferenceSettings, Disambiguation, DisplayCalendar, Overflow,
+        ResolvedRoundingOptions, Unit, UnitGroup,
     },
     parsers::IxdtfStringBuilder,
     provider::{NeverProvider, TimeZoneProvider},
@@ -194,7 +194,7 @@ impl PlainDate {
     pub(crate) fn add_duration_to_date(
         &self,
         duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         // 3. If operation is subtract, set duration to CreateNegatedTemporalDuration(duration).
         // 4. Let dateDuration be ToDateDurationRecordWithoutTime(duration).
@@ -202,7 +202,7 @@ impl PlainDate {
         let date_duration = duration.to_date_duration_record_without_time()?;
         // 5. Let resolvedOptions be ? GetOptionsObject(options).
         // 6. Let overflow be ? GetTemporalOverflowOption(resolvedOptions).
-        let overflow = overflow.unwrap_or(ArithmeticOverflow::Constrain);
+        let overflow = overflow.unwrap_or(Overflow::Constrain);
         // 7. Let result be ? CalendarDateAdd(calendar, temporalDate.[[ISODate]], dateDuration, overflow).
         // 8. Return ! CreateTemporalDate(result, calendar).
         self.calendar()
@@ -318,7 +318,7 @@ impl PlainDate {
     /// Creates a new `PlainDate` automatically constraining any values that may be invalid.
     #[inline]
     pub fn new(year: i32, month: u8, day: u8, calendar: Calendar) -> TemporalResult<Self> {
-        Self::new_with_overflow(year, month, day, calendar, ArithmeticOverflow::Constrain)
+        Self::new_with_overflow(year, month, day, calendar, Overflow::Constrain)
     }
 
     /// Creates a new `PlainDate` with an ISO 8601 calendar automatically constraining any
@@ -331,7 +331,7 @@ impl PlainDate {
     /// Creates a new `PlainDate` rejecting any date that may be invalid.
     #[inline]
     pub fn try_new(year: i32, month: u8, day: u8, calendar: Calendar) -> TemporalResult<Self> {
-        Self::new_with_overflow(year, month, day, calendar, ArithmeticOverflow::Reject)
+        Self::new_with_overflow(year, month, day, calendar, Overflow::Reject)
     }
 
     /// Creates a new `PlainDate` with an ISO 8601 calendar rejecting any date that may be invalid.
@@ -349,7 +349,7 @@ impl PlainDate {
         month: u8,
         day: u8,
         calendar: Calendar,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<Self> {
         let iso = IsoDate::new_with_overflow(year, month, day, overflow)?;
         Ok(Self::new_unchecked(iso, calendar))
@@ -377,10 +377,7 @@ impl PlainDate {
     ///
     /// ```
     #[inline]
-    pub fn from_partial(
-        partial: PartialDate,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn from_partial(partial: PartialDate, overflow: Option<Overflow>) -> TemporalResult<Self> {
         let year_check = partial.calendar_fields.year.is_some()
             || (partial.calendar_fields.era.is_some()
                 && partial.calendar_fields.era_year.is_some());
@@ -413,11 +410,7 @@ impl PlainDate {
     }
 
     /// Creates a date time with values from a `PartialDate`.
-    pub fn with(
-        &self,
-        fields: CalendarFields,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn with(&self, fields: CalendarFields, overflow: Option<Overflow>) -> TemporalResult<Self> {
         if fields.is_empty() {
             return Err(TemporalError::r#type().with_message("CalendarFields must have a field."));
         }
@@ -426,7 +419,7 @@ impl PlainDate {
         // 8. Let fields be ? CalendarMergeFields(calendarRec, fieldsResult.[[Fields]], partialDate).
         // 9. Set fields to ? PrepareTemporalFields(fields, fieldsResult.[[FieldNames]], «»).
         // 10. Return ? CalendarDateFromFields(calendarRec, fields, resolvedOptions).
-        let overflow = overflow.unwrap_or(ArithmeticOverflow::Constrain);
+        let overflow = overflow.unwrap_or(Overflow::Constrain);
         self.calendar.date_from_fields(
             fields.with_fallback_date(self, self.calendar.kind(), overflow)?,
             overflow,
@@ -490,11 +483,7 @@ impl PlainDate {
 
     #[inline]
     /// Adds a `Duration` to the current `Date`
-    pub fn add(
-        &self,
-        duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn add(&self, duration: &Duration, overflow: Option<Overflow>) -> TemporalResult<Self> {
         self.add_duration_to_date(duration, overflow)
     }
 
@@ -503,7 +492,7 @@ impl PlainDate {
     pub fn subtract(
         &self,
         duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         self.add_duration_to_date(&duration.negated(), overflow)
     }
@@ -630,13 +619,13 @@ impl PlainDate {
             .with_month(self.month())
             .with_month_code(self.month_code());
         self.calendar()
-            .year_month_from_fields(fields, ArithmeticOverflow::Constrain)
+            .year_month_from_fields(fields, Overflow::Constrain)
     }
 
     /// Converts the current `Date` into a `PlainMonthDay`
     #[inline]
     pub fn to_plain_month_day(&self) -> TemporalResult<PlainMonthDay> {
-        let overflow = ArithmeticOverflow::Constrain;
+        let overflow = Overflow::Constrain;
         self.calendar().month_day_from_fields(
             CalendarFields::default().with_fallback_date(self, self.calendar.kind(), overflow)?,
             overflow,
diff --git a/src/builtins/core/datetime.rs b/src/builtins/core/datetime.rs
index 819a278a9..e4dcd45e7 100644
--- a/src/builtins/core/datetime.rs
+++ b/src/builtins/core/datetime.rs
@@ -12,9 +12,8 @@ use crate::{
     },
     iso::{IsoDate, IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, Disambiguation,
-        DisplayCalendar, ResolvedRoundingOptions, RoundingOptions, ToStringRoundingOptions, Unit,
-        UnitGroup,
+        DifferenceOperation, DifferenceSettings, Disambiguation, DisplayCalendar, Overflow,
+        ResolvedRoundingOptions, RoundingOptions, ToStringRoundingOptions, Unit, UnitGroup,
     },
     parsers::IxdtfStringBuilder,
     primitive::FiniteF64,
@@ -218,7 +217,7 @@ impl PlainDateTime {
     fn add_or_subtract_duration(
         &self,
         duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         // SKIP: 1, 2, 3, 4
         // 5. Let internalDuration be ToInternalDurationRecordWith24HourDays(duration).
@@ -234,7 +233,7 @@ impl PlainDateTime {
         let added_date = self.calendar().date_add(
             &self.iso.date,
             &date_duration,
-            overflow.unwrap_or(ArithmeticOverflow::Constrain),
+            overflow.unwrap_or(Overflow::Constrain),
         )?;
         // 9. Let result be CombineISODateAndTimeRecord(addedDate, timeResult).
         let result = IsoDateTime::new(added_date.iso, time_result)?;
@@ -378,7 +377,7 @@ impl PlainDateTime {
             microsecond,
             nanosecond,
             calendar,
-            ArithmeticOverflow::Constrain,
+            Overflow::Constrain,
         )
     }
 
@@ -437,7 +436,7 @@ impl PlainDateTime {
             microsecond,
             nanosecond,
             calendar,
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
         )
     }
 
@@ -469,7 +468,7 @@ impl PlainDateTime {
         )
     }
 
-    /// Creates a new `DateTime` with the provided [`ArithmeticOverflow`] option.
+    /// Creates a new `DateTime` with the provided [`Overflow`] option.
     #[inline]
     #[allow(clippy::too_many_arguments)]
     pub fn new_with_overflow(
@@ -483,7 +482,7 @@ impl PlainDateTime {
         microsecond: u16,
         nanosecond: u16,
         calendar: Calendar,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<Self> {
         let iso_date = IsoDate::new_with_overflow(year, month, day, overflow)?;
         let iso_time = IsoTime::new(
@@ -547,7 +546,7 @@ impl PlainDateTime {
     /// ```
     pub fn from_partial(
         partial: PartialDateTime,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         if partial.fields.is_empty() {
             return Err(TemporalError::r#type().with_message("PartialDateTime cannot be empty."));
@@ -556,7 +555,7 @@ impl PlainDateTime {
         // 1. Let isoDate be ? CalendarDateFromFields(calendar, fields, overflow).
         let date = partial.calendar.date_from_fields(
             partial.fields.calendar_fields,
-            overflow.unwrap_or(ArithmeticOverflow::Constrain),
+            overflow.unwrap_or(Overflow::Constrain),
         )?;
         // 2. Let time be ? RegulateTime(fields.[[Hour]], fields.[[Minute]], fields.[[Second]], fields.[[Millisecond]], fields.[[Microsecond]], fields.[[Nanosecond]], overflow).
         let iso_time =
@@ -577,7 +576,7 @@ impl PlainDateTime {
             parsed.date.record.year,
             parsed.date.record.month,
             parsed.date.record.day,
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
         )?;
         let iso = IsoDateTime::new(date, parsed.time)?;
 
@@ -618,17 +617,13 @@ impl PlainDateTime {
     ///
     /// ```
     #[inline]
-    pub fn with(
-        &self,
-        fields: DateTimeFields,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn with(&self, fields: DateTimeFields, overflow: Option<Overflow>) -> TemporalResult<Self> {
         if fields.is_empty() {
             return Err(
                 TemporalError::r#type().with_message("A PartialDateTime must have a valid field.")
             );
         }
-        let overflow = overflow.unwrap_or(ArithmeticOverflow::Constrain);
+        let overflow = overflow.unwrap_or(Overflow::Constrain);
 
         let result_date = self.calendar.date_from_fields(
             fields
@@ -843,11 +838,7 @@ impl PlainDateTime {
 
     #[inline]
     /// Adds a `Duration` to the current `DateTime`.
-    pub fn add(
-        &self,
-        duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn add(&self, duration: &Duration, overflow: Option<Overflow>) -> TemporalResult<Self> {
         self.add_or_subtract_duration(duration, overflow)
     }
 
@@ -856,7 +847,7 @@ impl PlainDateTime {
     pub fn subtract(
         &self,
         duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         self.add_or_subtract_duration(&duration.negated(), overflow)
     }
diff --git a/src/builtins/core/duration.rs b/src/builtins/core/duration.rs
index c8f53de5a..0080c8d29 100644
--- a/src/builtins/core/duration.rs
+++ b/src/builtins/core/duration.rs
@@ -5,8 +5,8 @@ use crate::{
     error::ErrorMessage,
     iso::{IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, RelativeTo, ResolvedRoundingOptions, RoundingIncrement,
-        RoundingOptions, ToStringRoundingOptions, Unit,
+        Overflow, RelativeTo, ResolvedRoundingOptions, RoundingIncrement, RoundingOptions,
+        ToStringRoundingOptions, Unit,
     },
     parsers::{FormattableDateDuration, FormattableDuration, FormattableTimeDuration, Precision},
     primitive::FiniteF64,
@@ -218,7 +218,7 @@ impl PartialDuration {
 /// ### Date arithmetic with durations
 ///
 /// ```rust
-/// use temporal_rs::{PlainDate, Duration, options::ArithmeticOverflow};
+/// use temporal_rs::{PlainDate, Duration, options::Overflow};
 /// use core::str::FromStr;
 ///
 /// // January 31st in different years
@@ -228,8 +228,8 @@ impl PartialDuration {
 /// let one_month = Duration::from_str("P1M").unwrap();
 ///
 /// // Adding 1 month to Jan 31st gives different results:
-/// let feb_2023 = jan_31_2023.add(&one_month, Some(ArithmeticOverflow::Constrain)).unwrap();
-/// let feb_2024 = jan_31_2024.add(&one_month, Some(ArithmeticOverflow::Constrain)).unwrap();
+/// let feb_2023 = jan_31_2023.add(&one_month, Some(Overflow::Constrain)).unwrap();
+/// let feb_2024 = jan_31_2024.add(&one_month, Some(Overflow::Constrain)).unwrap();
 ///
 /// // 2023: Jan 31 + 1 month = Feb 28 (no Feb 31st exists)
 /// assert_eq!(feb_2023.day(), 28);
@@ -844,9 +844,9 @@ impl Duration {
                 // c. Let after1 be ? AddZonedDateTime(zonedRelativeTo.[[EpochNanoseconds]], timeZone, calendar, duration1, constrain).
                 // d. Let after2 be ? AddZonedDateTime(zonedRelativeTo.[[EpochNanoseconds]], timeZone, calendar, duration2, constrain).
                 let after1 =
-                    zdt.add_zoned_date_time(duration_one, ArithmeticOverflow::Constrain, provider)?;
+                    zdt.add_zoned_date_time(duration_one, Overflow::Constrain, provider)?;
                 let after2 =
-                    zdt.add_zoned_date_time(duration_two, ArithmeticOverflow::Constrain, provider)?;
+                    zdt.add_zoned_date_time(duration_two, Overflow::Constrain, provider)?;
                 // e. If after1 > after2, return 1𝔽.
                 // f. If after1 < after2, return -1𝔽.
                 // g. Return +0𝔽.
@@ -1157,7 +1157,7 @@ impl Duration {
                 // e. Let targetEpochNs be ? AddZonedDateTime(relativeEpochNs, timeZone, calendar, internalDuration, constrain).
                 let target_epoch_ns = zoned_relative_to.add_zoned_date_time(
                     internal_duration,
-                    ArithmeticOverflow::Constrain,
+                    Overflow::Constrain,
                     provider,
                 )?;
 
@@ -1201,7 +1201,7 @@ impl Duration {
                 let target_date = calendar.date_add(
                     &plain_relative_to.iso,
                     &date_duration,
-                    ArithmeticOverflow::Constrain,
+                    Overflow::Constrain,
                 )?;
 
                 // f. Let isoDateTime be CombineISODateAndTimeRecord(plainRelativeTo.[[ISODate]], MidnightTimeRecord()).
@@ -1290,7 +1290,7 @@ impl Duration {
                 // e. Let targetEpochNs be ? AddZonedDateTime(relativeEpochNs, timeZone, calendar, internalDuration, constrain).
                 let target_epoch_ns = zoned_datetime.add_zoned_date_time(
                     internal_duration,
-                    ArithmeticOverflow::Constrain,
+                    Overflow::Constrain,
                     provider,
                 )?;
                 // f. Let total be ? DifferenceZonedDateTimeWithTotal(relativeEpochNs, targetEpochNs, timeZone, calendar, unit).
@@ -1317,7 +1317,7 @@ impl Duration {
                 let target_date = plain_date.calendar().date_add(
                     &plain_date.iso,
                     &date_duration,
-                    ArithmeticOverflow::Constrain,
+                    Overflow::Constrain,
                 )?;
                 // f. Let isoDateTime be CombineISODateAndTimeRecord(plainRelativeTo.[[ISODate]], MidnightTimeRecord()).
                 let iso_date_time = IsoDateTime::new_unchecked(plain_date.iso, IsoTime::default());
diff --git a/src/builtins/core/duration/date.rs b/src/builtins/core/duration/date.rs
index b07a69ac1..273e2c1d2 100644
--- a/src/builtins/core/duration/date.rs
+++ b/src/builtins/core/duration/date.rs
@@ -1,8 +1,8 @@
 //! Implementation of a `DateDuration`
 
 use crate::{
-    iso::iso_date_to_epoch_days, options::ArithmeticOverflow, Duration, PlainDate, Sign,
-    TemporalError, TemporalResult,
+    iso::iso_date_to_epoch_days, options::Overflow, Duration, PlainDate, Sign, TemporalError,
+    TemporalResult,
 };
 
 use super::duration_sign;
@@ -134,7 +134,7 @@ impl DateDuration {
         let later = relative_to.calendar().date_add(
             &relative_to.iso,
             &ymw_duration,
-            ArithmeticOverflow::Constrain,
+            Overflow::Constrain,
         )?;
         // 4. Let epochDays1 be ISODateToEpochDays(plainRelativeTo.[[ISODate]].[[Year]], plainRelativeTo.[[ISODate]].[[Month]] - 1, plainRelativeTo.[[ISODate]].[[Day]]).
         let epoch_days_1 = iso_date_to_epoch_days(
diff --git a/src/builtins/core/duration/normalized.rs b/src/builtins/core/duration/normalized.rs
index 62bcb351a..feeb3f35b 100644
--- a/src/builtins/core/duration/normalized.rs
+++ b/src/builtins/core/duration/normalized.rs
@@ -8,8 +8,8 @@ use crate::{
     builtins::core::{timezone::TimeZone, PlainDate, PlainDateTime},
     iso::{IsoDate, IsoDateTime},
     options::{
-        ArithmeticOverflow, Disambiguation, ResolvedRoundingOptions, RoundingIncrement,
-        RoundingMode, Unit, UNIT_VALUE_TABLE,
+        Disambiguation, Overflow, ResolvedRoundingOptions, RoundingIncrement, RoundingMode, Unit,
+        UNIT_VALUE_TABLE,
     },
     primitive::FiniteF64,
     provider::TimeZoneProvider,
@@ -563,13 +563,13 @@ impl InternalDurationRecord {
         };
 
         // 7. Let start be ? CalendarDateAdd(calendar, isoDateTime.[[ISODate]], startDuration, constrain).
-        let start =
-            dt.calendar()
-                .date_add(&dt.iso.date, &start_duration, ArithmeticOverflow::Constrain)?;
+        let start = dt
+            .calendar()
+            .date_add(&dt.iso.date, &start_duration, Overflow::Constrain)?;
         // 8. Let end be ? CalendarDateAdd(calendar, isoDateTime.[[ISODate]], endDuration, constrain).
-        let end =
-            dt.calendar()
-                .date_add(&dt.iso.date, &end_duration, ArithmeticOverflow::Constrain)?;
+        let end = dt
+            .calendar()
+            .date_add(&dt.iso.date, &end_duration, Overflow::Constrain)?;
         // 9. Let startDateTime be CombineISODateAndTimeRecord(start, isoDateTime.[[Time]]).
         let start = IsoDateTime::new_unchecked(start.iso, dt.iso.time);
         // 10. Let endDateTime be CombineISODateAndTimeRecord(end, isoDateTime.[[Time]]).
@@ -658,7 +658,7 @@ impl InternalDurationRecord {
         // 1.Let start be ? CalendarDateAdd(calendar, isoDateTime.[[ISODate]], duration.[[Date]], constrain).
         let start = dt
             .calendar()
-            .date_add(&dt.iso.date, &d, ArithmeticOverflow::Constrain)?;
+            .date_add(&dt.iso.date, &d, Overflow::Constrain)?;
         // 2. Let startDateTime be CombineISODateAndTimeRecord(start, isoDateTime.[[Time]]).
         let start_dt = IsoDateTime::new_unchecked(start.iso, dt.iso.time);
 
@@ -886,11 +886,8 @@ impl InternalDurationRecord {
                 };
 
                 // iv. Let end be ? CalendarDateAdd(calendar, isoDateTime.[[ISODate]], endDuration, constrain).
-                let end = calendar.date_add(
-                    &iso_date_time.date,
-                    &end_duration,
-                    ArithmeticOverflow::Constrain,
-                )?;
+                let end =
+                    calendar.date_add(&iso_date_time.date, &end_duration, Overflow::Constrain)?;
 
                 // v. Let endDateTime be CombineISODateAndTimeRecord(end, isoDateTime.[[Time]]).
                 let end_date_time = IsoDateTime::new_unchecked(end.iso, iso_date_time.time);
diff --git a/src/builtins/core/month_day.rs b/src/builtins/core/month_day.rs
index cee859074..e0ce5bdc0 100644
--- a/src/builtins/core/month_day.rs
+++ b/src/builtins/core/month_day.rs
@@ -6,7 +6,7 @@ use core::str::FromStr;
 use crate::{
     builtins::calendar::CalendarFields,
     iso::{IsoDate, IsoDateTime, IsoTime},
-    options::{ArithmeticOverflow, Disambiguation, DisplayCalendar},
+    options::{Disambiguation, DisplayCalendar, Overflow},
     parsed_intermediates::ParsedDate,
     parsers::{FormattableCalendar, FormattableDate, FormattableMonthDay},
     provider::TimeZoneProvider,
@@ -33,13 +33,13 @@ use writeable::Writeable;
 /// ### Creating a PlainMonthDay
 ///
 /// ```rust
-/// use temporal_rs::{PlainMonthDay, Calendar, MonthCode, options::ArithmeticOverflow};
+/// use temporal_rs::{PlainMonthDay, Calendar, MonthCode, options::Overflow};
 ///
 /// // Create March 15th
 /// let md = PlainMonthDay::new_with_overflow(
 ///     3, 15,                           // month, day
 ///     Calendar::default(),             // ISO 8601 calendar
-///     ArithmeticOverflow::Reject,      // reject invalid dates
+///     Overflow::Reject,      // reject invalid dates
 ///     None                             // no reference year
 /// ).unwrap();
 ///
@@ -107,13 +107,13 @@ use writeable::Writeable;
 /// ### Handling leap year dates
 ///
 /// ```rust
-/// use temporal_rs::{PlainMonthDay, MonthCode, fields::CalendarFields, Calendar, options::ArithmeticOverflow};
+/// use temporal_rs::{PlainMonthDay, MonthCode, fields::CalendarFields, Calendar, options::Overflow};
 ///
 /// // February 29th (leap day)
 /// let leap_day = PlainMonthDay::new_with_overflow(
 ///     2, 29,
 ///     Calendar::default(),
-///     ArithmeticOverflow::Reject,
+///     Overflow::Reject,
 ///     Some(2024) // reference year 2024 (a leap year)
 /// ).unwrap();
 ///
@@ -183,7 +183,7 @@ impl PlainMonthDay {
         month: u8,
         day: u8,
         calendar: Calendar,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
         ref_year: Option<i32>,
     ) -> TemporalResult<Self> {
         let ry = ref_year.unwrap_or(1972);
@@ -231,25 +231,18 @@ impl PlainMonthDay {
         // 15. Set isoDate to ? CalendarMonthDayFromFields(calendar, result, constrain).
         intermediate
             .calendar()
-            .month_day_from_fields(fields, ArithmeticOverflow::Constrain)
+            .month_day_from_fields(fields, Overflow::Constrain)
     }
 
     /// Create a `PlainYearMonth` from a `PartialDate`
-    pub fn from_partial(
-        partial: PartialDate,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn from_partial(partial: PartialDate, overflow: Option<Overflow>) -> TemporalResult<Self> {
         partial
             .calendar
             .month_day_from_fields(partial.calendar_fields, overflow.unwrap_or_default())
     }
 
     /// Create a `PlainMonthDay` with the provided fields from a [`PartialDate`].
-    pub fn with(
-        &self,
-        fields: CalendarFields,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn with(&self, fields: CalendarFields, overflow: Option<Overflow>) -> TemporalResult<Self> {
         // Steps 1-6 are engine specific.
         // 5. Let fields be ISODateToFields(calendar, monthDay.[[ISODate]], month-day).
         // 6. Let partialMonthDay be ? PrepareCalendarFields(calendar, temporalMonthDayLike, « year, month, month-code, day », « », partial).
@@ -276,7 +269,7 @@ impl PlainMonthDay {
         // 10. Let isoDate be ? CalendarMonthDayFromFields(calendar, fields, overflow).
         // 11. Return ! CreateTemporalMonthDay(isoDate, calendar).
         self.calendar
-            .month_day_from_fields(merged, overflow.unwrap_or(ArithmeticOverflow::Constrain))
+            .month_day_from_fields(merged, overflow.unwrap_or(Overflow::Constrain))
     }
 
     /// Returns the ISO day value of `PlainMonthDay`.
@@ -355,8 +348,7 @@ impl PlainMonthDay {
         }
 
         // 8. Let isoDate be ? CalendarDateFromFields(calendar, mergedFields, constrain).
-        self.calendar
-            .date_from_fields(fields, ArithmeticOverflow::Constrain)
+        self.calendar.date_from_fields(fields, Overflow::Constrain)
     }
 
     /// Gets the epochMilliseconds represented by this YearMonth in the given timezone
@@ -434,14 +426,9 @@ mod tests {
 
     #[test]
     fn test_to_plain_date_with_year() {
-        let month_day = PlainMonthDay::new_with_overflow(
-            5,
-            15,
-            Calendar::default(),
-            ArithmeticOverflow::Reject,
-            None,
-        )
-        .unwrap();
+        let month_day =
+            PlainMonthDay::new_with_overflow(5, 15, Calendar::default(), Overflow::Reject, None)
+                .unwrap();
 
         let fields = CalendarFields::new().with_year(2025);
         let plain_date = month_day.to_plain_date(Some(fields)).unwrap();
@@ -454,14 +441,9 @@ mod tests {
     fn test_to_plain_date_with_era_and_era_year() {
         // Use a calendar that supports era/era_year, e.g., "gregory"
         let calendar = Calendar::from_str("gregory").unwrap();
-        let month_day = PlainMonthDay::new_with_overflow(
-            3,
-            10,
-            calendar.clone(),
-            ArithmeticOverflow::Reject,
-            None,
-        )
-        .unwrap();
+        let month_day =
+            PlainMonthDay::new_with_overflow(3, 10, calendar.clone(), Overflow::Reject, None)
+                .unwrap();
 
         // Era "ce" and era_year 2020 should resolve to year 2020 in Gregorian
         let fields = CalendarFields::new()
@@ -484,14 +466,9 @@ mod tests {
 
     #[test]
     fn test_to_plain_date_missing_year_and_era() {
-        let month_day = PlainMonthDay::new_with_overflow(
-            7,
-            4,
-            Calendar::default(),
-            ArithmeticOverflow::Reject,
-            None,
-        )
-        .unwrap();
+        let month_day =
+            PlainMonthDay::new_with_overflow(7, 4, Calendar::default(), Overflow::Reject, None)
+                .unwrap();
 
         // No year, no era/era_year
         let fields = CalendarFields::new();
@@ -503,14 +480,9 @@ mod tests {
     fn test_to_plain_date_with_fallback_logic_matches_date() {
         // This test ensures that the fallback logic in month_day matches the fallback logic in date.rs
         let calendar = Calendar::from_str("gregory").unwrap();
-        let month_day = PlainMonthDay::new_with_overflow(
-            12,
-            25,
-            calendar.clone(),
-            ArithmeticOverflow::Reject,
-            None,
-        )
-        .unwrap();
+        let month_day =
+            PlainMonthDay::new_with_overflow(12, 25, calendar.clone(), Overflow::Reject, None)
+                .unwrap();
 
         // Provide only era/era_year, not year
         let fields = CalendarFields::new()
@@ -579,7 +551,7 @@ mod tests {
                     };
 
                     let md = calendar
-                        .month_day_from_fields(calendar_fields, ArithmeticOverflow::Reject)
+                        .month_day_from_fields(calendar_fields, Overflow::Reject)
                         .unwrap();
 
                     assert!(
@@ -651,7 +623,7 @@ mod tests {
 
             let md_from_partial = md
                 .calendar()
-                .month_day_from_fields(calendar_fields, ArithmeticOverflow::Reject)
+                .month_day_from_fields(calendar_fields, Overflow::Reject)
                 .expect(string);
 
             assert_eq!(
diff --git a/src/builtins/core/time.rs b/src/builtins/core/time.rs
index 529347a32..0f328bddb 100644
--- a/src/builtins/core/time.rs
+++ b/src/builtins/core/time.rs
@@ -4,7 +4,7 @@ use crate::{
     builtins::{core::Duration, duration::normalized::InternalDurationRecord},
     iso::IsoTime,
     options::{
-        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, ResolvedRoundingOptions,
+        DifferenceOperation, DifferenceSettings, Overflow, ResolvedRoundingOptions,
         RoundingIncrement, RoundingMode, ToStringRoundingOptions, Unit, UnitGroup,
     },
     parsers::{parse_time, IxdtfStringBuilder},
@@ -317,7 +317,7 @@ impl PlainTime {
             millisecond,
             microsecond,
             nanosecond,
-            ArithmeticOverflow::Constrain,
+            Overflow::Constrain,
         )
     }
 
@@ -346,11 +346,11 @@ impl PlainTime {
             millisecond,
             microsecond,
             nanosecond,
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
         )
     }
 
-    /// Creates a new `PlainTime` with the provided [`ArithmeticOverflow`] option.
+    /// Creates a new `PlainTime` with the provided [`Overflow`] option.
     #[inline]
     pub fn new_with_overflow(
         hour: u8,
@@ -359,7 +359,7 @@ impl PlainTime {
         millisecond: u16,
         microsecond: u16,
         nanosecond: u16,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<Self> {
         let time = IsoTime::new(
             hour,
@@ -393,10 +393,7 @@ impl PlainTime {
     /// assert_eq!(time.nanosecond(), 0);
     ///
     /// ```
-    pub fn from_partial(
-        partial: PartialTime,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn from_partial(partial: PartialTime, overflow: Option<Overflow>) -> TemporalResult<Self> {
         // NOTE: 4.5.12 ToTemporalTimeRecord requires one field to be set.
         if partial.is_empty() {
             return Err(TemporalError::r#type().with_message("PartialTime cannot be empty."));
@@ -436,11 +433,7 @@ impl PlainTime {
     /// assert_eq!(time.nanosecond(), 789);
     ///
     /// ```
-    pub fn with(
-        &self,
-        partial: PartialTime,
-        overflow: Option<ArithmeticOverflow>,
-    ) -> TemporalResult<Self> {
+    pub fn with(&self, partial: PartialTime, overflow: Option<Overflow>) -> TemporalResult<Self> {
         // NOTE: 4.5.12 ToTemporalTimeRecord requires one field to be set.
         if partial.is_empty() {
             return Err(TemporalError::r#type().with_message("PartialTime cannot be empty."));
@@ -448,7 +441,7 @@ impl PlainTime {
 
         let iso = self
             .iso
-            .with(partial, overflow.unwrap_or(ArithmeticOverflow::Constrain))?;
+            .with(partial, overflow.unwrap_or(Overflow::Constrain))?;
         Ok(Self::new_unchecked(iso))
     }
 
@@ -594,7 +587,7 @@ mod tests {
     use crate::{
         builtins::core::Duration,
         iso::IsoTime,
-        options::{ArithmeticOverflow, DifferenceSettings, RoundingIncrement, Unit},
+        options::{DifferenceSettings, Overflow, RoundingIncrement, Unit},
     };
     use num_traits::FromPrimitive;
 
@@ -725,14 +718,11 @@ mod tests {
     #[test]
     fn since_basic() {
         let one =
-            PlainTime::new_with_overflow(15, 23, 30, 123, 456, 789, ArithmeticOverflow::Constrain)
-                .unwrap();
+            PlainTime::new_with_overflow(15, 23, 30, 123, 456, 789, Overflow::Constrain).unwrap();
         let two =
-            PlainTime::new_with_overflow(14, 23, 30, 123, 456, 789, ArithmeticOverflow::Constrain)
-                .unwrap();
+            PlainTime::new_with_overflow(14, 23, 30, 123, 456, 789, Overflow::Constrain).unwrap();
         let three =
-            PlainTime::new_with_overflow(13, 30, 30, 123, 456, 789, ArithmeticOverflow::Constrain)
-                .unwrap();
+            PlainTime::new_with_overflow(13, 30, 30, 123, 456, 789, Overflow::Constrain).unwrap();
 
         let result = one.since(&two, DifferenceSettings::default()).unwrap();
         assert_eq!(result.hours(), 1);
@@ -752,14 +742,11 @@ mod tests {
     #[test]
     fn until_basic() {
         let one =
-            PlainTime::new_with_overflow(15, 23, 30, 123, 456, 789, ArithmeticOverflow::Constrain)
-                .unwrap();
+            PlainTime::new_with_overflow(15, 23, 30, 123, 456, 789, Overflow::Constrain).unwrap();
         let two =
-            PlainTime::new_with_overflow(16, 23, 30, 123, 456, 789, ArithmeticOverflow::Constrain)
-                .unwrap();
+            PlainTime::new_with_overflow(16, 23, 30, 123, 456, 789, Overflow::Constrain).unwrap();
         let three =
-            PlainTime::new_with_overflow(17, 0, 30, 123, 456, 789, ArithmeticOverflow::Constrain)
-                .unwrap();
+            PlainTime::new_with_overflow(17, 0, 30, 123, 456, 789, Overflow::Constrain).unwrap();
 
         let result = one.until(&two, DifferenceSettings::default()).unwrap();
         assert_eq!(result.hours(), 1);
@@ -806,83 +793,67 @@ mod tests {
     // test262/test/built-ins/Temporal/PlainTime/prototype/round/roundingincrement-nanoseconds.js
     fn rounding_increment_nanos() {
         let time =
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 321, ArithmeticOverflow::Constrain)
-                .unwrap();
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 321, Overflow::Constrain).unwrap();
 
         assert_eq!(
             time.round(Unit::Nanosecond, Some(1.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 321, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 321, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(2.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 322, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 322, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(4.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(5.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(8.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(10.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(20.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(25.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 325, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 325, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(40.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 320, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(50.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 300, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 300, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(100.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 300, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 300, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(125.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 375, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 375, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(200.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 400, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 400, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(250.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 250, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 250, Overflow::Constrain).unwrap()
         );
         assert_eq!(
             time.round(Unit::Nanosecond, Some(500.0), None).unwrap(),
-            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 500, ArithmeticOverflow::Constrain)
-                .unwrap()
+            PlainTime::new_with_overflow(3, 34, 56, 987, 654, 500, Overflow::Constrain).unwrap()
         );
     }
 
diff --git a/src/builtins/core/year_month.rs b/src/builtins/core/year_month.rs
index af1ac6c7c..7c2979347 100644
--- a/src/builtins/core/year_month.rs
+++ b/src/builtins/core/year_month.rs
@@ -9,8 +9,8 @@ use crate::{
     builtins::calendar::{CalendarFields, YearMonthCalendarFields},
     iso::{year_month_within_limits, IsoDate, IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, Disambiguation,
-        DisplayCalendar, ResolvedRoundingOptions, RoundingIncrement, Unit, UnitGroup,
+        DifferenceOperation, DifferenceSettings, Disambiguation, DisplayCalendar, Overflow,
+        ResolvedRoundingOptions, RoundingIncrement, Unit, UnitGroup,
     },
     parsed_intermediates::ParsedDate,
     parsers::{FormattableCalendar, FormattableDate, FormattableYearMonth},
@@ -183,7 +183,7 @@ impl PlainYearMonth {
     pub(crate) fn add_duration(
         &self,
         duration: &Duration,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<Self> {
         // NOTE: The following are engine specific:
         //    SKIP: 1. Let duration be ? ToTemporalDuration(temporalDurationLike).
@@ -219,7 +219,7 @@ impl PlainYearMonth {
             let next_month = calendar.date_add(
                 &intermediate_date.iso,
                 &one_month_duration,
-                ArithmeticOverflow::Constrain,
+                Overflow::Constrain,
             )?;
 
             // c. Let date be BalanceISODate(nextMonth.[[Year]], nextMonth.[[Month]], nextMonth.[[Day]] - 1).
@@ -360,13 +360,7 @@ impl PlainYearMonth {
         reference_day: Option<u8>,
         calendar: Calendar,
     ) -> TemporalResult<Self> {
-        Self::new_with_overflow(
-            year,
-            month,
-            reference_day,
-            calendar,
-            ArithmeticOverflow::Constrain,
-        )
+        Self::new_with_overflow(year, month, reference_day, calendar, Overflow::Constrain)
     }
 
     /// Creates a new `PlainYearMonth`, rejecting any date that may be invalid.
@@ -377,13 +371,7 @@ impl PlainYearMonth {
         reference_day: Option<u8>,
         calendar: Calendar,
     ) -> TemporalResult<Self> {
-        Self::new_with_overflow(
-            year,
-            month,
-            reference_day,
-            calendar,
-            ArithmeticOverflow::Reject,
-        )
+        Self::new_with_overflow(year, month, reference_day, calendar, Overflow::Reject)
     }
 
     /// Creates a new `PlainYearMonth` with an ISO 8601 calendar, rejecting any date that may be invalid.
@@ -399,14 +387,14 @@ impl PlainYearMonth {
         Self::new(year, month, reference_day, Calendar::default())
     }
 
-    /// Creates a new valid `YearMonth` with provided `ArithmeticOverflow` option.
+    /// Creates a new valid `YearMonth` with provided [`Overflow`] option.
     #[inline]
     pub fn new_with_overflow(
         year: i32,
         month: u8,
         reference_day: Option<u8>,
         calendar: Calendar,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<Self> {
         let day = reference_day.unwrap_or(1);
         let iso = IsoDate::regulate(year, month, day, overflow)?;
@@ -419,7 +407,7 @@ impl PlainYearMonth {
     /// Create a `PlainYearMonth` from a `PartialYearMonth`
     pub fn from_partial(
         partial: PartialYearMonth,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         partial
             .calendar
@@ -457,7 +445,7 @@ impl PlainYearMonth {
         // 15. Return ! CreateTemporalYearMonth(isoDate, calendar).
         intermediate
             .calendar()
-            .year_month_from_fields(fields, ArithmeticOverflow::Constrain)
+            .year_month_from_fields(fields, Overflow::Constrain)
     }
 
     /// Returns the iso year value for this `YearMonth`.
@@ -560,7 +548,7 @@ impl PlainYearMonth {
     pub fn with(
         &self,
         fields: YearMonthCalendarFields,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
     ) -> TemporalResult<Self> {
         // 1. Let yearMonth be the this value.
         // 2. Perform ? RequireInternalSlot(yearMonth, [[InitializedTemporalYearMonth]]).
@@ -573,7 +561,7 @@ impl PlainYearMonth {
         // 9. Let overflow be ? GetTemporalOverflowOption(resolvedOptions).
         // 10. Let isoDate be ? CalendarYearMonthFromFields(calendar, fields, overflow).
         // 11. Return ! CreateTemporalYearMonth(isoDate, calendar).
-        let overflow = overflow.unwrap_or(ArithmeticOverflow::Constrain);
+        let overflow = overflow.unwrap_or(Overflow::Constrain);
         self.calendar.year_month_from_fields(
             fields.with_fallback_year_month(self, self.calendar.kind(), overflow)?,
             overflow,
@@ -596,17 +584,13 @@ impl PlainYearMonth {
 
     /// Adds a [`Duration`] from the current `PlainYearMonth`.
     #[inline]
-    pub fn add(&self, duration: &Duration, overflow: ArithmeticOverflow) -> TemporalResult<Self> {
+    pub fn add(&self, duration: &Duration, overflow: Overflow) -> TemporalResult<Self> {
         self.add_duration(duration, overflow)
     }
 
     /// Subtracts a [`Duration`] from the current `PlainYearMonth`.
     #[inline]
-    pub fn subtract(
-        &self,
-        duration: &Duration,
-        overflow: ArithmeticOverflow,
-    ) -> TemporalResult<Self> {
+    pub fn subtract(&self, duration: &Duration, overflow: Overflow) -> TemporalResult<Self> {
         self.add_duration(&duration.negated(), overflow)
     }
 
@@ -636,8 +620,7 @@ impl PlainYearMonth {
             .with_day(day_value);
 
         // 8. Let isoDate be ? CalendarDateFromFields(calendar, mergedFields, constrain).
-        self.calendar
-            .date_from_fields(fields, ArithmeticOverflow::Constrain)
+        self.calendar.date_from_fields(fields, Overflow::Constrain)
     }
 
     /// Gets the epochMilliseconds represented by this YearMonth in the given timezone
@@ -838,7 +821,7 @@ mod tests {
             1,
             None,
             Calendar::from_str("islamic").unwrap(),
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
         )
         .unwrap();
 
@@ -847,7 +830,7 @@ mod tests {
             1,
             None,
             Calendar::from_str("hebrew").unwrap(),
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
         )
         .unwrap();
 
@@ -944,14 +927,9 @@ mod tests {
 
     #[test]
     fn test_plain_year_month_with() {
-        let base = PlainYearMonth::new_with_overflow(
-            2025,
-            3,
-            None,
-            Calendar::default(),
-            ArithmeticOverflow::Reject,
-        )
-        .unwrap();
+        let base =
+            PlainYearMonth::new_with_overflow(2025, 3, None, Calendar::default(), Overflow::Reject)
+                .unwrap();
 
         // Year
         let fields = YearMonthCalendarFields::new().with_year(2001);
@@ -1041,7 +1019,7 @@ mod tests {
             5,    // month
             None, // reference_day
             Calendar::default(),
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
         )
         .unwrap();
 
diff --git a/src/builtins/core/zoneddatetime.rs b/src/builtins/core/zoneddatetime.rs
index fa99126c8..8d4fdfc4b 100644
--- a/src/builtins/core/zoneddatetime.rs
+++ b/src/builtins/core/zoneddatetime.rs
@@ -19,10 +19,9 @@ use crate::{
     error::ErrorMessage,
     iso::{IsoDate, IsoDateTime, IsoTime},
     options::{
-        ArithmeticOverflow, DifferenceOperation, DifferenceSettings, Disambiguation,
-        DisplayCalendar, DisplayOffset, DisplayTimeZone, OffsetDisambiguation,
-        ResolvedRoundingOptions, RoundingIncrement, RoundingMode, RoundingOptions,
-        ToStringRoundingOptions, Unit, UnitGroup,
+        DifferenceOperation, DifferenceSettings, Disambiguation, DisplayCalendar, DisplayOffset,
+        DisplayTimeZone, OffsetDisambiguation, Overflow, ResolvedRoundingOptions,
+        RoundingIncrement, RoundingMode, RoundingOptions, ToStringRoundingOptions, Unit, UnitGroup,
     },
     parsed_intermediates::ParsedZonedDateTime,
     parsers::{FormattableOffset, FormattableTime, IxdtfStringBuilder, Precision},
@@ -311,7 +310,7 @@ impl ZonedDateTime {
     pub(crate) fn add_zoned_date_time(
         &self,
         duration: InternalDurationRecord,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
         provider: &impl TimeZoneProvider,
     ) -> TemporalResult<Instant> {
         // 1. If DateDurationSign(duration.[[Date]]) = 0, then
@@ -353,7 +352,7 @@ impl ZonedDateTime {
     pub(crate) fn add_internal(
         &self,
         duration: &Duration,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
         provider: &impl TimeZoneProvider,
     ) -> TemporalResult<Self> {
         // 1. Let duration be ? ToTemporalDuration(temporalDurationLike).
@@ -645,12 +644,12 @@ impl ZonedDateTime {
     #[inline]
     pub fn from_partial_with_provider(
         partial: PartialZonedDateTime,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
         disambiguation: Option<Disambiguation>,
         offset_option: Option<OffsetDisambiguation>,
         provider: &impl TimeZoneProvider,
     ) -> TemporalResult<Self> {
-        let overflow = overflow.unwrap_or(ArithmeticOverflow::Constrain);
+        let overflow = overflow.unwrap_or(Overflow::Constrain);
         let disambiguation = disambiguation.unwrap_or(Disambiguation::Compatible);
         let offset_option = offset_option.unwrap_or(OffsetDisambiguation::Reject);
 
@@ -708,7 +707,7 @@ impl ZonedDateTime {
         fields: ZonedDateTimeFields,
         disambiguation: Option<Disambiguation>,
         offset_option: Option<OffsetDisambiguation>,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
         provider: &impl TimeZoneProvider,
     ) -> TemporalResult<Self> {
         let overflow = overflow.unwrap_or_default();
@@ -1096,26 +1095,22 @@ impl ZonedDateTime {
     pub fn add_with_provider(
         &self,
         duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
         provider: &impl TimeZoneProvider,
     ) -> TemporalResult<Self> {
-        self.add_internal(
-            duration,
-            overflow.unwrap_or(ArithmeticOverflow::Constrain),
-            provider,
-        )
+        self.add_internal(duration, overflow.unwrap_or(Overflow::Constrain), provider)
     }
 
     /// Subtract a duration to the current `ZonedDateTime`
     pub fn subtract_with_provider(
         &self,
         duration: &Duration,
-        overflow: Option<ArithmeticOverflow>,
+        overflow: Option<Overflow>,
         provider: &impl TimeZoneProvider,
     ) -> TemporalResult<Self> {
         self.add_internal(
             &duration.negated(),
-            overflow.unwrap_or(ArithmeticOverflow::Constrain),
+            overflow.unwrap_or(Overflow::Constrain),
             provider,
         )
     }
@@ -1387,7 +1382,7 @@ impl ZonedDateTime {
             parsed.date.record.year,
             parsed.date.record.month,
             parsed.date.record.day,
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
         )?;
 
         let epoch_nanos = interpret_isodatetime_offset(
@@ -1563,8 +1558,8 @@ mod tests {
     use crate::{
         builtins::{calendar::CalendarFields, zoneddatetime::ZonedDateTimeFields},
         options::{
-            ArithmeticOverflow, DifferenceSettings, Disambiguation, OffsetDisambiguation,
-            RoundingIncrement, RoundingMode, RoundingOptions, Unit,
+            DifferenceSettings, Disambiguation, OffsetDisambiguation, Overflow, RoundingIncrement,
+            RoundingMode, RoundingOptions, Unit,
         },
         partial::{PartialTime, PartialZonedDateTime},
         tzdb::FsTzdbProvider,
@@ -1901,7 +1896,7 @@ mod tests {
         )
         .unwrap();
 
-        let overflow = ArithmeticOverflow::Reject;
+        let overflow = Overflow::Reject;
 
         let result_1 = zdt.with_with_provider(
             ZonedDateTimeFields {
diff --git a/src/iso.rs b/src/iso.rs
index 9caa587cd..7e141b8f9 100644
--- a/src/iso.rs
+++ b/src/iso.rs
@@ -35,7 +35,7 @@ use crate::{
         PartialTime, PlainDate,
     },
     error::{ErrorMessage, TemporalError},
-    options::{ArithmeticOverflow, ResolvedRoundingOptions, Unit},
+    options::{Overflow, ResolvedRoundingOptions, Unit},
     rounding::IncrementRounder,
     unix_time::EpochNanoseconds,
     utils, TemporalResult, TemporalUnwrap, NS_PER_DAY,
@@ -273,16 +273,16 @@ impl IsoDate {
         year: i32,
         month: u8,
         day: u8,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<Self> {
         match overflow {
-            ArithmeticOverflow::Constrain => {
+            Overflow::Constrain => {
                 let month = month.clamp(1, 12);
                 let day = constrain_iso_day(year, month, day);
                 // NOTE: Values are clamped in a u8 range.
                 Ok(Self::new_unchecked(year, month, day))
             }
-            ArithmeticOverflow::Reject => {
+            Overflow::Reject => {
                 if !is_valid_date(year, month, day) {
                     return Err(TemporalError::range().with_message("not a valid ISO date."));
                 }
@@ -314,7 +314,7 @@ impl IsoDate {
         year: i32,
         month: u8,
         day: u8,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<Self> {
         let date = Self::regulate(year, month, day, overflow)?;
         if !iso_dt_within_valid_limits(date, &IsoTime::noon()) {
@@ -376,7 +376,7 @@ impl IsoDate {
     pub(crate) fn add_date_duration(
         self,
         duration: &DateDuration,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<Self> {
         // 1. Assert: year, month, day, years, months, weeks, and days are integers.
         // 2. Assert: overflow is either "constrain" or "reject".
@@ -480,7 +480,7 @@ impl IsoDate {
             intermediate.0,
             intermediate.1,
             self.day,
-            ArithmeticOverflow::Constrain,
+            Overflow::Constrain,
         )?;
 
         // NOTE: Below is adapted from the polyfill. Preferring this as it avoids looping.
@@ -561,10 +561,10 @@ impl IsoTime {
         millisecond: u16,
         microsecond: u16,
         nanosecond: u16,
-        overflow: ArithmeticOverflow,
+        overflow: Overflow,
     ) -> TemporalResult<IsoTime> {
         match overflow {
-            ArithmeticOverflow::Constrain => {
+            Overflow::Constrain => {
                 let h = hour.clamp(0, 23);
                 let min = minute.clamp(0, 59);
                 let sec = second.clamp(0, 59);
@@ -573,7 +573,7 @@ impl IsoTime {
                 let nano = nanosecond.clamp(0, 999);
                 Ok(Self::new_unchecked(h, min, sec, milli, micro, nano))
             }
-            ArithmeticOverflow::Reject => {
+            Overflow::Reject => {
                 if !is_valid_time(hour, minute, second, millisecond, microsecond, nanosecond) {
                     return Err(TemporalError::range().with_message("IsoTime is not valid"));
                 };
@@ -591,11 +591,7 @@ impl IsoTime {
 
     /// Creates a new `Time` with the fields provided from a `PartialTime`.
     #[inline]
-    pub(crate) fn with(
-        &self,
-        partial: PartialTime,
-        overflow: ArithmeticOverflow,
-    ) -> TemporalResult<Self> {
+    pub(crate) fn with(&self, partial: PartialTime, overflow: Overflow) -> TemporalResult<Self> {
         let hour = partial.hour.unwrap_or(self.hour);
         let minute = partial.minute.unwrap_or(self.minute);
         let second = partial.second.unwrap_or(self.second);
@@ -649,7 +645,7 @@ impl IsoTime {
             millisecond as u16,
             micros as u16,
             nanos as u16,
-            ArithmeticOverflow::Reject,
+            Overflow::Reject,
         )
     }
 
diff --git a/src/options.rs b/src/options.rs
index e40750c5d..075b9a476 100644
--- a/src/options.rs
+++ b/src/options.rs
@@ -586,11 +586,11 @@ impl fmt::Display for Unit {
     }
 }
 
-/// `ArithmeticOverflow` can also be used as an
+/// `Overflow` can also be used as an
 /// assignment overflow and consists of the "constrain"
 /// and "reject" options.
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
-pub enum ArithmeticOverflow {
+pub enum Overflow {
     /// Constrain option
     #[default]
     Constrain,
@@ -600,27 +600,27 @@ pub enum ArithmeticOverflow {
 
 /// A parsing error for `ArithemeticOverflow`
 #[derive(Debug, Clone, Copy)]
-pub struct ParseArithmeticOverflowError;
+pub struct ParseOverflowError;
 
-impl fmt::Display for ParseArithmeticOverflowError {
+impl fmt::Display for ParseOverflowError {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_str("provided string was not a valid overflow value")
     }
 }
 
-impl FromStr for ArithmeticOverflow {
-    type Err = ParseArithmeticOverflowError;
+impl FromStr for Overflow {
+    type Err = ParseOverflowError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
             "constrain" => Ok(Self::Constrain),
             "reject" => Ok(Self::Reject),
-            _ => Err(ParseArithmeticOverflowError),
+            _ => Err(ParseOverflowError),
         }
     }
 }
 
-impl fmt::Display for ArithmeticOverflow {
+impl fmt::Display for Overflow {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         match self {
             Self::Constrain => "constrain",
@@ -630,47 +630,6 @@ impl fmt::Display for ArithmeticOverflow {
     }
 }
 
-/// `Duration` overflow options.
-#[derive(Debug, Clone, Copy)]
-pub enum DurationOverflow {
-    /// Constrain option
-    Constrain,
-    /// Balance option
-    Balance,
-}
-
-/// A parsing error for `DurationOverflow`.
-#[derive(Debug, Clone, Copy)]
-pub struct ParseDurationOverflowError;
-
-impl fmt::Display for ParseDurationOverflowError {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        f.write_str("provided string was not a valid duration overflow value")
-    }
-}
-
-impl FromStr for DurationOverflow {
-    type Err = ParseDurationOverflowError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "constrain" => Ok(Self::Constrain),
-            "balance" => Ok(Self::Balance),
-            _ => Err(ParseDurationOverflowError),
-        }
-    }
-}
-
-impl fmt::Display for DurationOverflow {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        match self {
-            Self::Constrain => "constrain",
-            Self::Balance => "balance",
-        }
-        .fmt(f)
-    }
-}
-
 /// The disambiguation options for an instant.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub enum Disambiguation {
diff --git a/src/options/relative_to.rs b/src/options/relative_to.rs
index 1c558f980..eacd25669 100644
--- a/src/options/relative_to.rs
+++ b/src/options/relative_to.rs
@@ -3,7 +3,7 @@
 use crate::builtins::core::zoneddatetime::interpret_isodatetime_offset;
 use crate::builtins::core::{calendar::Calendar, timezone::TimeZone, PlainDate, ZonedDateTime};
 use crate::iso::{IsoDate, IsoTime};
-use crate::options::{ArithmeticOverflow, Disambiguation, OffsetDisambiguation};
+use crate::options::{Disambiguation, OffsetDisambiguation, Overflow};
 use crate::parsers::{parse_date_time, parse_zoned_date_time};
 use crate::provider::TimeZoneProvider;
 use crate::{TemporalResult, TemporalUnwrap};
@@ -104,12 +104,7 @@ impl RelativeTo {
         let time = result.time.map(IsoTime::from_time_record).transpose()?;
 
         let date = result.date.temporal_unwrap()?;
-        let iso = IsoDate::new_with_overflow(
-            date.year,
-            date.month,
-            date.day,
-            ArithmeticOverflow::Constrain,
-        )?;
+        let iso = IsoDate::new_with_overflow(date.year, date.month, date.day, Overflow::Constrain)?;
 
         let epoch_ns = interpret_isodatetime_offset(
             iso,
diff --git a/temporal_capi/bindings/c/DurationOverflow.d.h b/temporal_capi/bindings/c/DurationOverflow.d.h
deleted file mode 100644
index d8be690f2..000000000
--- a/temporal_capi/bindings/c/DurationOverflow.d.h
+++ /dev/null
@@ -1,23 +0,0 @@
-#ifndef DurationOverflow_D_H
-#define DurationOverflow_D_H
-
-#include <stdio.h>
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include "diplomat_runtime.h"
-
-
-
-
-
-typedef enum DurationOverflow {
-  DurationOverflow_Constrain = 0,
-  DurationOverflow_Balance = 1,
-} DurationOverflow;
-
-typedef struct DurationOverflow_option {union { DurationOverflow ok; }; bool is_ok; } DurationOverflow_option;
-
-
-
-#endif // DurationOverflow_D_H
diff --git a/temporal_capi/bindings/c/DurationOverflow.h b/temporal_capi/bindings/c/DurationOverflow.h
deleted file mode 100644
index 54e133748..000000000
--- a/temporal_capi/bindings/c/DurationOverflow.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef DurationOverflow_H
-#define DurationOverflow_H
-
-#include <stdio.h>
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include "diplomat_runtime.h"
-
-
-#include "DurationOverflow.d.h"
-
-
-
-
-
-
-
-
-
-
-#endif // DurationOverflow_H
diff --git a/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.d.hpp
deleted file mode 100644
index e5cc449c8..000000000
--- a/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.d.hpp
+++ /dev/null
@@ -1,49 +0,0 @@
-#ifndef temporal_rs_DurationOverflow_D_HPP
-#define temporal_rs_DurationOverflow_D_HPP
-
-#include <stdio.h>
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <memory>
-#include <functional>
-#include <optional>
-#include <cstdlib>
-#include "../diplomat_runtime.hpp"
-
-
-namespace temporal_rs {
-namespace capi {
-    enum DurationOverflow {
-      DurationOverflow_Constrain = 0,
-      DurationOverflow_Balance = 1,
-    };
-
-    typedef struct DurationOverflow_option {union { DurationOverflow ok; }; bool is_ok; } DurationOverflow_option;
-} // namespace capi
-} // namespace
-
-namespace temporal_rs {
-class DurationOverflow {
-public:
-  enum Value {
-    Constrain = 0,
-    Balance = 1,
-  };
-
-  DurationOverflow(): value(Value::Constrain) {}
-
-  // Implicit conversions between enum and ::Value
-  constexpr DurationOverflow(Value v) : value(v) {}
-  constexpr operator Value() const { return value; }
-  // Prevent usage as boolean value
-  explicit operator bool() const = delete;
-
-  inline temporal_rs::capi::DurationOverflow AsFFI() const;
-  inline static temporal_rs::DurationOverflow FromFFI(temporal_rs::capi::DurationOverflow c_enum);
-private:
-    Value value;
-};
-
-} // namespace
-#endif // temporal_rs_DurationOverflow_D_HPP
diff --git a/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.hpp b/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.hpp
deleted file mode 100644
index 5080bc18d..000000000
--- a/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.hpp
+++ /dev/null
@@ -1,38 +0,0 @@
-#ifndef temporal_rs_DurationOverflow_HPP
-#define temporal_rs_DurationOverflow_HPP
-
-#include "DurationOverflow.d.hpp"
-
-#include <stdio.h>
-#include <stdint.h>
-#include <stddef.h>
-#include <stdbool.h>
-#include <memory>
-#include <functional>
-#include <optional>
-#include <cstdlib>
-#include "../diplomat_runtime.hpp"
-
-
-namespace temporal_rs {
-namespace capi {
-    extern "C" {
-
-    } // extern "C"
-} // namespace capi
-} // namespace
-
-inline temporal_rs::capi::DurationOverflow temporal_rs::DurationOverflow::AsFFI() const {
-  return static_cast<temporal_rs::capi::DurationOverflow>(value);
-}
-
-inline temporal_rs::DurationOverflow temporal_rs::DurationOverflow::FromFFI(temporal_rs::capi::DurationOverflow c_enum) {
-  switch (c_enum) {
-    case temporal_rs::capi::DurationOverflow_Constrain:
-    case temporal_rs::capi::DurationOverflow_Balance:
-      return static_cast<temporal_rs::DurationOverflow::Value>(c_enum);
-    default:
-      std::abort();
-  }
-}
-#endif // temporal_rs_DurationOverflow_HPP
diff --git a/temporal_capi/src/options.rs b/temporal_capi/src/options.rs
index 6c4d29e0c..c6f169e04 100644
--- a/temporal_capi/src/options.rs
+++ b/temporal_capi/src/options.rs
@@ -7,7 +7,7 @@ pub mod ffi {
     use diplomat_runtime::DiplomatOption;
     use temporal_rs::options;
 
-    #[diplomat::enum_convert(options::ArithmeticOverflow)]
+    #[diplomat::enum_convert(options::Overflow)]
     pub enum ArithmeticOverflow {
         #[diplomat::attr(auto, default)]
         Constrain,
@@ -46,12 +46,6 @@ pub mod ffi {
         Critical,
     }
 
-    #[diplomat::enum_convert(options::DurationOverflow)]
-    pub enum DurationOverflow {
-        Constrain,
-        Balance,
-    }
-
     #[diplomat::enum_convert(options::OffsetDisambiguation)]
     pub enum OffsetDisambiguation {
         Use,