@js-joda/core 3.2.0 → 4.2.1

package/dist/js-joda.d.ts

@@ -266,15 +266,7 @@ export abstract class TemporalAccessor {
  * discussion of the issues.
  */
 export abstract class Temporal extends TemporalAccessor {
-    abstract isSupported(field: TemporalField): boolean;
-    /**
-     * Checks if the specified unit is supported.
-     *
-     * This checks if the date-time can be queried for the specified unit. If false, then calling
-     * the plus and minus methods will throw an exception.
-     */
-    abstract isSupported(unit: TemporalUnit): boolean;
-    abstract minus(amountToSubtract: number, unit: TemporalUnit): Temporal;
+    minus(amountToSubtract: number, unit: TemporalUnit): Temporal;
     /**
      * Returns an object of the same type as this object with an amount subtracted.
      *
@@ -291,8 +283,8 @@ export abstract class Temporal extends TemporalAccessor {
      *
      * Note that calling plus followed by minus is not guaranteed to return the same date-time.
      */
-    abstract minus(amount: TemporalAmount): Temporal;
-    abstract plus(amountToAdd: number, unit: TemporalUnit): Temporal;
+    minus(amount: TemporalAmount): Temporal;
+    plus(amountToAdd: number, unit: TemporalUnit): Temporal;
     /**
      * Returns an object of the same type as this object with an amount added.
      *
@@ -309,7 +301,49 @@ export abstract class Temporal extends TemporalAccessor {
      *
      * Note that calling plus followed by minus is not guaranteed to return the same date-time.
      */
-    abstract plus(amount: TemporalAmount): Temporal;
+    plus(amount: TemporalAmount): Temporal;
+    /**
+     * Returns an adjusted object of the same type as this object with the adjustment made.
+     *
+     * This adjusts this date-time according to the rules of the specified adjuster. A simple
+     * adjuster might simply set the one of the fields, such as the year field. A more complex
+     * adjuster might set the date to the last day of the month. A selection of common adjustments
+     * is provided in `TemporalAdjusters`. These include finding the "last day of the month" and
+     * "next Wednesday". The adjuster is responsible for handling special cases, such as the
+     * varying lengths of month and leap years.
+     *
+     * Some example code indicating how and why this method is used:
+     * ```
+     * date = date.with(Month.JULY);        // most key classes implement TemporalAdjuster
+     * date = date.with(lastDayOfMonth());  // static import from TemporalAdjusters
+     * date = date.with(next(WEDNESDAY));   // static import from TemporalAdjusters and DayOfWeek
+     * ```
+     */
+    with(adjuster: TemporalAdjuster): Temporal;
+    /**
+     * Returns an object of the same type as this object with the specified field altered.
+     *
+     * This returns a new object based on this one with the value for the specified field changed.
+     * For example, on a `LocalDate`, this could be used to set the year, month or day-of-month.
+     * The returned object will have the same observable type as this object.
+     *
+     * In some cases, changing a field is not fully defined. For example, if the target object is
+     * a date representing the 31st January, then changing the month to February would be unclear.
+     * In cases like this, the field is responsible for resolving the result. Typically it will
+     * choose the previous valid date, which would be the last valid day of February in this
+     * example.
+     */
+    with(field: TemporalField, newValue: number): Temporal;
+
+    abstract isSupported(field: TemporalField): boolean;
+    /**
+     * Checks if the specified unit is supported.
+     *
+     * This checks if the date-time can be queried for the specified unit. If false, then calling
+     * the plus and minus methods will throw an exception.
+     */
+    abstract isSupported(unit: TemporalUnit): boolean;
+
     /**
      * Calculates the period between this temporal and another temporal in terms of the
      * specified unit.
@@ -341,38 +375,14 @@ export abstract class Temporal extends TemporalAccessor {
      * ```
      */
     abstract until(endTemporal: Temporal, unit: TemporalUnit): number;
-    /**
-     * Returns an adjusted object of the same type as this object with the adjustment made.
-     *
-     * This adjusts this date-time according to the rules of the specified adjuster. A simple
-     * adjuster might simply set the one of the fields, such as the year field. A more complex
-     * adjuster might set the date to the last day of the month. A selection of common adjustments
-     * is provided in `TemporalAdjusters`. These include finding the "last day of the month" and
-     * "next Wednesday". The adjuster is responsible for handling special cases, such as the
-     * varying lengths of month and leap years.
-     *
-     * Some example code indicating how and why this method is used:
-     * ```
-     * date = date.with(Month.JULY);        // most key classes implement TemporalAdjuster
-     * date = date.with(lastDayOfMonth());  // static import from TemporalAdjusters
-     * date = date.with(next(WEDNESDAY));   // static import from TemporalAdjusters and DayOfWeek
-     * ```
-     */
-    abstract with(adjuster: TemporalAdjuster): Temporal;
-    /**
-     * Returns an object of the same type as this object with the specified field altered.
-     *
-     * This returns a new object based on this one with the value for the specified field changed.
-     * For example, on a `LocalDate`, this could be used to set the year, month or day-of-month.
-     * The returned object will have the same observable type as this object.
-     *
-     * In some cases, changing a field is not fully defined. For example, if the target object is
-     * a date representing the 31st January, then changing the month to February would be unclear.
-     * In cases like this, the field is responsible for resolving the result. Typically it will
-     * choose the previous valid date, which would be the last valid day of February in this
-     * example.
-     */
-    abstract with(field: TemporalField, newValue: number): Temporal;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): Temporal;
+    protected _minusAmount(amount: TemporalAmount): Temporal;
+    protected _plusAmount(amount: TemporalAmount): Temporal;
+    protected _withAdjuster(adjuster: TemporalAdjuster): Temporal;
+
+    protected abstract _plusUnit(amountToAdd: number, unit: TemporalUnit): Temporal;
+    protected abstract _withField(field: TemporalField, newValue: number): Temporal;
 }
 
 /**
@@ -1149,6 +1159,7 @@ export class Instant extends Temporal implements TemporalAdjuster {
     private constructor();
 
     adjustInto(temporal: Temporal): Temporal;
+    atOffset(offset: ZoneOffset): OffsetDateTime;
     atZone(zone: ZoneId): ZonedDateTime;
     compareTo(otherInstant: Instant): number;
     epochSecond(): number;
@@ -1158,14 +1169,14 @@ export class Instant extends Temporal implements TemporalAdjuster {
     isAfter(otherInstant: Instant): boolean;
     isBefore(otherInstant: Instant): boolean;
     isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean;
-    minus(amount: TemporalAmount): Instant;
     minus(amountToSubtract: number, unit: TemporalUnit): Instant;
+    minus(amount: TemporalAmount): Instant;
     minusMillis(millisToSubtract: number): Instant;
     minusNanos(nanosToSubtract: number): Instant;
     minusSeconds(secondsToSubtract: number): Instant;
     nano(): number;
-    plus(amount: TemporalAmount): Instant;
     plus(amountToAdd: number, unit: TemporalUnit): Instant;
+    plus(amount: TemporalAmount): Instant;
     plusMillis(millisToAdd: number): Instant;
     plusNanos(nanosToAdd: number): Instant;
     plusSeconds(secondsToAdd: number): Instant;
@@ -1176,6 +1187,13 @@ export class Instant extends Temporal implements TemporalAdjuster {
     until(endExclusive: Temporal, unit: TemporalUnit): number;
     with(adjuster: TemporalAdjuster): Instant;
     with(field: TemporalField, newValue: number): Instant;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): Instant;
+    protected _minusAmount(amount: TemporalAmount): Instant;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): Instant;
+    protected _plusAmount(amount: TemporalAmount): Instant;
+    protected _withAdjuster(adjuster: TemporalAdjuster): Instant;
+    protected _withField(field: TemporalField, newValue: number): Instant;
 }
 
 export class LocalDate extends ChronoLocalDate implements TemporalAdjuster {
@@ -1199,6 +1217,7 @@ export class LocalDate extends ChronoLocalDate implements TemporalAdjuster {
     atStartOfDay(zone: ZoneId): ZonedDateTime;
     atTime(hour: number, minute: number, second?: number, nanoOfSecond?: number): LocalDateTime;
     atTime(time: LocalTime): LocalDateTime;
+    atTime(time: OffsetTime): OffsetDateTime;
     chronology(): Chronology;
     compareTo(other: LocalDate): number;
     dayOfMonth(): number;
@@ -1216,16 +1235,16 @@ export class LocalDate extends ChronoLocalDate implements TemporalAdjuster {
     isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean;
     lengthOfMonth(): number;
     lengthOfYear(): number;
-    minus(amount: TemporalAmount): LocalDate;
     minus(amountToSubtract: number, unit: TemporalUnit): LocalDate;
+    minus(amount: TemporalAmount): LocalDate;
     minusDays(daysToSubtract: number): LocalDate;
     minusMonths(monthsToSubtract: number): LocalDate;
     minusWeeks(weeksToSubtract: number): LocalDate;
     minusYears(yearsToSubtract: number): LocalDate;
     month(): Month;
     monthValue(): number;
-    plus(amount: TemporalAmount): LocalDate;
     plus(amountToAdd: number, unit: TemporalUnit): LocalDate;
+    plus(amount: TemporalAmount): LocalDate;
     plusDays(daysToAdd: number): LocalDate;
     plusMonths(monthsToAdd: number): LocalDate;
     plusWeeks(weeksToAdd: number): LocalDate;
@@ -1242,6 +1261,13 @@ export class LocalDate extends ChronoLocalDate implements TemporalAdjuster {
     withMonth(month: Month | number): LocalDate;
     withYear(year: number): LocalDate;
     year(): number;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): LocalDate;
+    protected _minusAmount(amount: TemporalAmount): LocalDate;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): LocalDate;
+    protected _plusAmount(amount: TemporalAmount): LocalDate;
+    protected _withAdjuster(adjuster: TemporalAdjuster): LocalDate;
+    protected _withField(field: TemporalField, newValue: number): LocalDate;
 }
 
 export class LocalDateTime extends ChronoLocalDateTime implements TemporalAdjuster {
@@ -1276,8 +1302,8 @@ export class LocalDateTime extends ChronoLocalDateTime implements TemporalAdjust
     isBefore(other: LocalDateTime): boolean;
     isEqual(other: LocalDateTime): boolean;
     isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean;
-    minus(amount: TemporalAmount): LocalDateTime;
     minus(amountToSubtract: number, unit: TemporalUnit): LocalDateTime;
+    minus(amount: TemporalAmount): LocalDateTime;
     minusDays(days: number): LocalDateTime;
     minusHours(hours: number): LocalDateTime;
     minusMinutes(minutes: number): LocalDateTime;
@@ -1290,8 +1316,8 @@ export class LocalDateTime extends ChronoLocalDateTime implements TemporalAdjust
     month(): Month;
     monthValue(): number;
     nano(): number;
-    plus(amount: TemporalAmount): LocalDateTime;
     plus(amountToAdd: number, unit: TemporalUnit): LocalDateTime;
+    plus(amount: TemporalAmount): LocalDateTime;
     plusDays(days: number): LocalDateTime;
     plusHours(hours: number): LocalDateTime;
     plusMinutes(minutes: number): LocalDateTime;
@@ -1318,6 +1344,13 @@ export class LocalDateTime extends ChronoLocalDateTime implements TemporalAdjust
     withSecond(second: number): LocalDateTime;
     withYear(year: number): LocalDateTime;
     year(): number;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): LocalDateTime;
+    protected _minusAmount(amount: TemporalAmount): LocalDateTime;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): LocalDateTime;
+    protected _plusAmount(amount: TemporalAmount): LocalDateTime;
+    protected _withAdjuster(adjuster: TemporalAdjuster): LocalDateTime;
+    protected _withField(field: TemporalField, newValue: number): LocalDateTime;
 }
 
 export class LocalTime extends Temporal implements TemporalAdjuster {
@@ -1352,6 +1385,7 @@ export class LocalTime extends Temporal implements TemporalAdjuster {
 
     adjustInto(temporal: Temporal): Temporal;
     atDate(date: LocalDate): LocalDateTime;
+    atOffset(offset: ZoneOffset): OffsetTime;
     compareTo(other: LocalTime): number;
     equals(other: any): boolean;
     format(formatter: DateTimeFormatter): string;
@@ -1361,16 +1395,16 @@ export class LocalTime extends Temporal implements TemporalAdjuster {
     isAfter(other: LocalTime): boolean;
     isBefore(other: LocalTime): boolean;
     isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean;
-    minus(amount: TemporalAmount): LocalTime;
     minus(amountToSubtract: number, unit: TemporalUnit): LocalTime;
+    minus(amount: TemporalAmount): LocalTime;
     minusHours(hoursToSubtract: number): LocalTime;
     minusMinutes(minutesToSubtract: number): LocalTime;
     minusNanos(nanosToSubtract: number): LocalTime;
     minusSeconds(secondsToSubtract: number): LocalTime;
     minute(): number;
     nano(): number;
-    plus(amount: TemporalAmount): LocalTime;
     plus(amountToAdd: number, unit: TemporalUnit): LocalTime;
+    plus(amount: TemporalAmount): LocalTime;
     plusHours(hoursToAdd: number): LocalTime;
     plusMinutes(minutesToAdd: number): LocalTime;
     plusNanos(nanosToAdd: number): LocalTime;
@@ -1389,6 +1423,13 @@ export class LocalTime extends Temporal implements TemporalAdjuster {
     withMinute(minute: number): LocalTime;
     withNano(nanoOfSecond: number): LocalTime;
     withSecond(second: number): LocalTime;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): LocalTime;
+    protected _minusAmount(amount: TemporalAmount): LocalTime;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): LocalTime;
+    protected _plusAmount(amount: TemporalAmount): LocalTime;
+    protected _withAdjuster(adjuster: TemporalAdjuster): LocalTime;
+    protected _withField(field: TemporalField, newValue: number): LocalTime;
 }
 
 export class MonthDay extends TemporalAccessor implements TemporalAdjuster {
@@ -1493,11 +1534,11 @@ export class Year extends Temporal implements TemporalAdjuster {
     isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean;
     isValidMonthDay(monthDay: MonthDay): boolean;
     length(): number;
-    minus(amount: TemporalAmount): Year;
     minus(amountToSubtract: number, unit: TemporalUnit): Year;
+    minus(amount: TemporalAmount): Year;
     minusYears(yearsToSubtract: number): Year;
-    plus(amount: TemporalAmount): Year;
     plus(amountToAdd: number, unit: TemporalUnit): Year;
+    plus(amount: TemporalAmount): Year;
     plusYears(yearsToAdd: number): Year;
     toJSON(): string;
     toString(): string;
@@ -1505,6 +1546,13 @@ export class Year extends Temporal implements TemporalAdjuster {
     value(): number;
     with(adjuster: TemporalAdjuster): Year;
     with(field: TemporalField, newValue: number): Year;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): Year;
+    protected _minusAmount(amount: TemporalAmount): Year;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): Year;
+    protected _plusAmount(amount: TemporalAmount): Year;
+    protected _withAdjuster(adjuster: TemporalAdjuster): Year;
+    protected _withField(field: TemporalField, newValue: number): Year;
 }
 
 export class YearMonth extends Temporal implements TemporalAdjuster {
@@ -1531,14 +1579,14 @@ export class YearMonth extends Temporal implements TemporalAdjuster {
     isValidDay(): boolean;
     lengthOfMonth(): number;
     lengthOfYear(): number;
-    minus(amount: TemporalAmount): YearMonth;
     minus(amountToSubtract: number, unit: TemporalUnit): YearMonth;
+    minus(amount: TemporalAmount): YearMonth;
     minusMonths(monthsToSubtract: number): YearMonth;
     minusYears(yearsToSubtract: number): YearMonth;
     month(): Month;
     monthValue(): number;
-    plus(amount: TemporalAmount): YearMonth;
     plus(amountToAdd: number, unit: TemporalUnit): YearMonth;
+    plus(amount: TemporalAmount): YearMonth;
     plusMonths(monthsToAdd: number): YearMonth;
     plusYears(yearsToAdd: number): YearMonth;
     toJSON(): string;
@@ -1548,6 +1596,13 @@ export class YearMonth extends Temporal implements TemporalAdjuster {
     withMonth(month: number): YearMonth;
     withYear(year: number): YearMonth;
     year(): number;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): YearMonth;
+    protected _minusAmount(amount: TemporalAmount): YearMonth;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): YearMonth;
+    protected _plusAmount(amount: TemporalAmount): YearMonth;
+    protected _withAdjuster(adjuster: TemporalAdjuster): YearMonth;
+    protected _withField(field: TemporalField, newValue: number): YearMonth;
 }
 
 /**
@@ -1587,74 +1642,78 @@ export class OffsetDateTime extends Temporal implements TemporalAdjuster {
 
     private constructor();
 
-    adjustInto(temporal: Temporal): Temporal
-    atZoneSameInstant(zone: ZoneId): ZonedDateTime
-    atZoneSimilarLocal(zone: ZoneId): ZonedDateTime
-    compareTo(other: OffsetDateTime): number
-    equals(obj: any): boolean
-    format(formatter: DateTimeFormatter): string
-    get(field: TemporalField): number
-    dayOfMonth(): number
-    dayOfWeek(): DayOfWeek
-    dayOfYear(): number
-    hour(): number
-    getLong(field: TemporalField): number
-    minute(): number
-    month(): Month
-    monthValue(): number
-    nano(): number
-    offset(): ZoneOffset
-    second(): number
-    year(): number
-    hashCode(): number
-    isAfter(other: OffsetDateTime): boolean
-    isBefore(other: OffsetDateTime): boolean
-    isEqual(other: OffsetDateTime): boolean
-    isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean
-    minus(amountToSubtract: number, unit: TemporalUnit): OffsetDateTime
-    minus(amountToSubtract: TemporalAmount): OffsetDateTime
-    minusDays(days: number): OffsetDateTime
-    minusHours(hours: number): OffsetDateTime
-    minusMinutes(minutes: number): OffsetDateTime
-    minusMonths(months: number): OffsetDateTime
-    minusNanos(nanos: number): OffsetDateTime
-    minusSeconds(seconds: number): OffsetDateTime
-    minusWeeks(weeks: number): OffsetDateTime
-    minusYears(years: number): OffsetDateTime
-    plus(amountToAdd: number, unit: TemporalUnit): OffsetDateTime
-    plus(amountToAdd: TemporalAmount): OffsetDateTime
-    plusDays(days: number): OffsetDateTime
-    plusHours(hours: number): OffsetDateTime
-    plusMinutes(minutes: number): OffsetDateTime
-    plusMonths(months: number): OffsetDateTime
-    plusNanos(nanos: number): OffsetDateTime
-    plusSeconds(seconds: number): OffsetDateTime
-    plusWeeks(weeks: number): OffsetDateTime
-    plusYears(years: number): OffsetDateTime
-    query<T>(query: TemporalQuery<T>): T
-    range(field: TemporalField): ValueRange
-    toEpochSecond(): number
+    adjustInto(temporal: Temporal): Temporal;
+    atZoneSameInstant(zone: ZoneId): ZonedDateTime;
+    atZoneSimilarLocal(zone: ZoneId): ZonedDateTime;
+    compareTo(other: OffsetDateTime): number;
+    dayOfMonth(): number;
+    dayOfWeek(): DayOfWeek;
+    dayOfYear(): number;
+    equals(other: any): boolean;
+    format(formatter: DateTimeFormatter): string;
+    getLong(field: TemporalField): number;
+    hashCode(): number;
+    hour(): number;
+    isAfter(other: OffsetDateTime): boolean;
+    isBefore(other: OffsetDateTime): boolean;
+    isEqual(other: OffsetDateTime): boolean;
+    isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean;
+    minus(amountToSubtract: number, unit: TemporalUnit): OffsetDateTime;
+    minus(amount: TemporalAmount): OffsetDateTime;
+    minusDays(days: number): OffsetDateTime;
+    minusHours(hours: number): OffsetDateTime;
+    minusMinutes(minutes: number): OffsetDateTime;
+    minusMonths(months: number): OffsetDateTime;
+    minusNanos(nanos: number): OffsetDateTime;
+    minusSeconds(seconds: number): OffsetDateTime;
+    minusWeeks(weeks: number): OffsetDateTime;
+    minusYears(years: number): OffsetDateTime;
+    minute(): number;
+    month(): Month;
+    monthValue(): number;
+    nano(): number;
+    offset(): ZoneOffset;
+    plus(amountToAdd: number, unit: TemporalUnit): OffsetDateTime;
+    plus(amount: TemporalAmount): OffsetDateTime;
+    plusDays(days: number): OffsetDateTime;
+    plusHours(hours: number): OffsetDateTime;
+    plusMinutes(minutes: number): OffsetDateTime;
+    plusMonths(months: number): OffsetDateTime;
+    plusNanos(nanos: number): OffsetDateTime;
+    plusSeconds(seconds: number): OffsetDateTime;
+    plusWeeks(weeks: number): OffsetDateTime;
+    plusYears(years: number): OffsetDateTime;
+    second(): number;
+    toEpochSecond(): number;
+    toInstant(): Instant;
     toJSON(): string;
-    toInstant(): Instant
-    toLocalDate(): LocalDate
-    toLocalDateTime(): LocalDateTime
-    toLocalTime(): LocalTime
-    toOffsetTime(): OffsetTime
-    toString(): string
-    truncatedTo(unit: TemporalUnit): OffsetDateTime
-    until(endExclusive: Temporal, unit: TemporalUnit): number
-    with(adjuster: TemporalAdjuster): OffsetDateTime
-    with(field: TemporalField, newValue: number): OffsetDateTime
-    withDayOfMonth(dayOfMonth: number): OffsetDateTime
-    withDayOfYear(dayOfYear: number): OffsetDateTime
-    withHour(hour: number): OffsetDateTime
-    withMinute(minute: number): OffsetDateTime
-    withMonth(month: number): OffsetDateTime
-    withNano(nanoOfSecond: number): OffsetDateTime
-    withOffsetSameInstant(offset: ZoneOffset): OffsetDateTime
-    withOffsetSameLocal(offset: ZoneOffset): OffsetDateTime
-    withSecond(second: number): OffsetDateTime
-    withYear(year: number): OffsetDateTime
+    toLocalDate(): LocalDate;
+    toLocalDateTime(): LocalDateTime;
+    toLocalTime(): LocalTime;
+    toOffsetTime(): OffsetTime;
+    toString(): string;
+    truncatedTo(unit: TemporalUnit): OffsetDateTime;
+    until(endExclusive: Temporal, unit: TemporalUnit): number;
+    with(adjuster: TemporalAdjuster): OffsetDateTime;
+    with(field: TemporalField, newValue: number): OffsetDateTime;
+    withDayOfMonth(dayOfMonth: number): OffsetDateTime;
+    withDayOfYear(dayOfYear: number): OffsetDateTime;
+    withHour(hour: number): OffsetDateTime;
+    withMinute(minute: number): OffsetDateTime;
+    withMonth(month: number): OffsetDateTime;
+    withNano(nanoOfSecond: number): OffsetDateTime;
+    withOffsetSameInstant(offset: ZoneOffset): OffsetDateTime;
+    withOffsetSameLocal(offset: ZoneOffset): OffsetDateTime;
+    withSecond(second: number): OffsetDateTime;
+    withYear(year: number): OffsetDateTime;
+    year(): number;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): OffsetDateTime;
+    protected _minusAmount(amount: TemporalAmount): OffsetDateTime;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): OffsetDateTime;
+    protected _plusAmount(amount: TemporalAmount): OffsetDateTime;
+    protected _withAdjuster(adjuster: TemporalAdjuster): OffsetDateTime;
+    protected _withField(field: TemporalField, newValue: number): OffsetDateTime;
 }
 
 /**
@@ -1683,51 +1742,55 @@ export class OffsetTime extends Temporal implements TemporalAdjuster {
 
     private constructor();
 
-    adjustInto(temporal: Temporal): Temporal
-    atDate(date: LocalDate): OffsetDateTime
-    compareTo(other: OffsetTime): number
-    equals(other: any): boolean
-    format(formatter: DateTimeFormatter): string
-    get(field: TemporalField): number
-    hour(): number
-    getLong(field: TemporalField): number
-    minute(): number
-    nano(): number
-    offset(): ZoneOffset
-    second(): number
-    hashCode(): number
-    isAfter(other: OffsetTime): boolean
-    isBefore(other: OffsetTime): boolean
-    isEqual(other: OffsetTime): boolean
-    isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean
-    minus(amountToSubtract: number, unit: TemporalUnit): OffsetTime
-    minus(amountToSubtract: TemporalAmount): OffsetTime
-    minusHours(hours: number): OffsetTime
-    minusMinutes(minutes: number): OffsetTime
-    minusNanos(nanos: number): OffsetTime
-    minusSeconds(seconds: number): OffsetTime
-    plus(amountToAdd: number, unit: TemporalUnit): OffsetTime
-    plus(amountToAdd: TemporalAmount): OffsetTime
-    plusHours(hours: number): OffsetTime
-    plusMinutes(minutes: number): OffsetTime
-    plusNanos(nanos: number): OffsetTime
-    plusSeconds(seconds: number): OffsetTime
-    query<T>(query: TemporalQuery<T>): T
-    range(field: TemporalField): ValueRange
-    toEpochSecond(date: LocalDate): number
+    adjustInto(temporal: Temporal): Temporal;
+    atDate(date: LocalDate): OffsetDateTime;
+    compareTo(other: OffsetTime): number;
+    equals(other: any): boolean;
+    format(formatter: DateTimeFormatter): string;
+    getLong(field: TemporalField): number;
+    hashCode(): number;
+    hour(): number;
+    isAfter(other: OffsetTime): boolean;
+    isBefore(other: OffsetTime): boolean;
+    isEqual(other: OffsetTime): boolean;
+    isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean;
+    minus(amountToSubtract: number, unit: TemporalUnit): OffsetTime;
+    minus(amount: TemporalAmount): OffsetTime;
+    minusHours(hours: number): OffsetTime;
+    minusMinutes(minutes: number): OffsetTime;
+    minusNanos(nanos: number): OffsetTime;
+    minusSeconds(seconds: number): OffsetTime;
+    minute(): number;
+    nano(): number;
+    offset(): ZoneOffset;
+    plus(amountToAdd: number, unit: TemporalUnit): OffsetTime;
+    plus(amount: TemporalAmount): OffsetTime;
+    plusHours(hours: number): OffsetTime;
+    plusMinutes(minutes: number): OffsetTime;
+    plusNanos(nanos: number): OffsetTime;
+    plusSeconds(seconds: number): OffsetTime;
+    second(): number;
+    toEpochSecond(date: LocalDate): number;
     toJSON(): string;
-    toLocalTime(): LocalTime
-    toString(): string
-    truncatedTo(unit: TemporalUnit): OffsetTime
-    until(endExclusive: Temporal, unit: TemporalUnit): number
-    with(adjuster: TemporalAdjuster): OffsetTime
-    with(field: TemporalField, newValue: number): OffsetTime
-    withHour(hour: number): OffsetTime
-    withMinute(minute: number): OffsetTime
-    withNano(nanoOfSecond: number): OffsetTime
-    withOffsetSameInstant(offset: ZoneOffset): OffsetTime
-    withOffsetSameLocal(offset: ZoneOffset): OffsetTime
-    withSecond(second: number): OffsetTime
+    toLocalTime(): LocalTime;
+    toString(): string;
+    truncatedTo(unit: TemporalUnit): OffsetTime;
+    until(endExclusive: Temporal, unit: TemporalUnit): number;
+    with(adjuster: TemporalAdjuster): OffsetTime;
+    with(field: TemporalField, newValue: number): OffsetTime;
+    withHour(hour: number): OffsetTime;
+    withMinute(minute: number): OffsetTime;
+    withNano(nanoOfSecond: number): OffsetTime;
+    withOffsetSameInstant(offset: ZoneOffset): OffsetTime;
+    withOffsetSameLocal(offset: ZoneOffset): OffsetTime;
+    withSecond(second: number): OffsetTime;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): OffsetTime;
+    protected _minusAmount(amount: TemporalAmount): OffsetTime;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): OffsetTime;
+    protected _plusAmount(amount: TemporalAmount): OffsetTime;
+    protected _withAdjuster(adjuster: TemporalAdjuster): OffsetTime;
+    protected _withField(field: TemporalField, newValue: number): OffsetTime;
 }
 
 /**
@@ -1838,13 +1901,12 @@ export class ZonedDateTime extends ChronoZonedDateTime {
     dayOfWeek(): DayOfWeek;
     dayOfYear(): number;
     equals(other: any): boolean;
-    format(formatter: DateTimeFormatter): string;
     getLong(field: TemporalField): number;
     hashCode(): number;
     hour(): number;
     isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean;
-    minus(amount: TemporalAmount): ZonedDateTime;
     minus(amountToSubtract: number, unit: TemporalUnit): ZonedDateTime;
+    minus(amount: TemporalAmount): ZonedDateTime;
     minusDays(days: number): ZonedDateTime;
     minusHours(hours: number): ZonedDateTime;
     minusMinutes(minutes: number): ZonedDateTime;
@@ -1858,8 +1920,8 @@ export class ZonedDateTime extends ChronoZonedDateTime {
     monthValue(): number;
     nano(): number;
     offset(): ZoneOffset;
-    plus(amount: TemporalAmount): ZonedDateTime;
     plus(amountToAdd: number, unit: TemporalUnit): ZonedDateTime;
+    plus(amount: TemporalAmount): ZonedDateTime;
     plusDays(days: number): ZonedDateTime;
     plusHours(hours: number): ZonedDateTime;
     plusMinutes(minutes: number): ZonedDateTime;
@@ -1949,6 +2011,13 @@ export class ZonedDateTime extends ChronoZonedDateTime {
     withZoneSameLocal(zone: ZoneId): ZonedDateTime;
     year(): number;
     zone(): ZoneId;
+
+    protected _minusUnit(amountToSubtract: number, unit: TemporalUnit): ZonedDateTime;
+    protected _minusAmount(amount: TemporalAmount): ZonedDateTime;
+    protected _plusUnit(amountToAdd: number, unit: TemporalUnit): ZonedDateTime;
+    protected _plusAmount(amount: TemporalAmount): ZonedDateTime;
+    protected _withAdjuster(adjuster: TemporalAdjuster): ZonedDateTime;
+    protected _withField(field: TemporalField, newValue: number): ZonedDateTime;
 }
 
 export abstract class ZoneId {
@@ -2028,7 +2097,6 @@ export class DayOfWeek extends TemporalAccessor implements TemporalAdjuster {
     adjustInto(temporal: Temporal): Temporal;
     compareTo(other: DayOfWeek): number;
     equals(other: any): boolean;
-    displayName(style: TextStyle, locale: Locale): string;
     getLong(field: TemporalField): number;
     isSupported(field: TemporalField): boolean;
     minus(days: number): DayOfWeek;
@@ -2066,7 +2134,6 @@ export class Month extends TemporalAccessor implements TemporalAdjuster {
     equals(other: any): boolean;
     firstDayOfYear(leapYear: boolean): number;
     firstMonthOfQuarter(): Month;
-    displayName(style: TextStyle, locale: Locale): string;
     getLong(field: TemporalField): number;
     isSupported(field: TemporalField): boolean;
     length(leapYear: boolean): number;
@@ -2091,6 +2158,7 @@ export class DateTimeFormatter {
     static ISO_LOCAL_DATE_TIME: DateTimeFormatter;
     static ISO_INSTANT: DateTimeFormatter;
     static ISO_OFFSET_DATE_TIME: DateTimeFormatter;
+    static ISO_OFFSET_TIME: DateTimeFormatter;
     static ISO_ZONED_DATE_TIME: DateTimeFormatter;
 
     static ofPattern(pattern: string): DateTimeFormatter;
@@ -2102,13 +2170,11 @@ export class DateTimeFormatter {
     chronology(): Chronology | null;
     decimalStyle(): DecimalStyle;
     format(temporal: TemporalAccessor): string;
-    locale(): any;
     parse(text: string): TemporalAccessor;
     parse<T>(text: string, query: TemporalQuery<T>): T;
     parseUnresolved(text: string, position: ParsePosition): TemporalAccessor;
     toString(): string;
     withChronology(chrono: Chronology): DateTimeFormatter;
-    withLocale(locale: Locale): DateTimeFormatter;
     withResolverStyle(resolverStyle: ResolverStyle): DateTimeFormatter;
 }
 
@@ -2410,14 +2476,10 @@ export abstract class ChronoZonedDateTime extends Temporal {
 //   SUPPORT
 // ----------------------------------------------------------------------------
 
-export interface Locale {
-    // TODO: Not implemented yet
-}
-
 export function nativeJs(date: Date | any, zone?: ZoneId): TemporalAccessor;
 
 export function convert(
-    temporal: LocalDate | LocalDateTime | ZonedDateTime,
+    temporal: LocalDate | LocalDateTime | ZonedDateTime | Instant,
     zone?: ZoneId,
 ): {
     toDate: () => Date;