@item-enonic-types/lib-time 1.6.1 → 2.0.0

package/README.md

@@ -1,14 +1,17 @@
 # Time library for Enonic XP
 
-This library enables the usage of classes from the [`java.time`](https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/package-summary.html) package from Enonic XP application code.
+This library enables the usage of classes from the [`java.time`](https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/package-summary.html) package from Enonic XP application code.
 Other JavaScript-based time libraries like _Moment.js_ or _date-fns_ will negatively impact your bundle size and build time. This library is only a **thin TypeScript-wrapper** around the excellent core `java.time` library already present in your system!
 
 [![](https://repo.itemtest.no/api/badge/latest/releases/no/item/lib-xp-time)](https://repo.itemtest.no/#/releases/no/item/lib-xp-time)
+![Enonic XP8 badge](https://market.enonic.com/badges/xp8.svg)
 
 <img src="https://github.com/ItemConsulting/lib-xp-time/raw/main/docs/icon.svg?sanitize=true" width="150">
 
 ## Installation
 
+Version 2 of this library requires Enonic XP 8, and is built against XP 8.0.0. Use version 1.x for Enonic XP 7.
+
 To install this library you need to add a new dependency to your app's build.gradle file.
 
 ### Gradle
@@ -19,7 +22,7 @@ repositories {
 }
 
 dependencies {
-  include "no.item:lib-xp-time:1.5.0"
+  include "no.item:lib-xp-time:2.0.0"
 }
 ```
 
@@ -72,31 +75,112 @@ const time = fiftyMinutesAgo.toLocalTime();
 // time = "11:25:30"
 ```
 
-*This library also exposes a utility function `formatDate()` to simply format a date:*
+### Amounts of time with `Duration`, `Period` and `ChronoUnit`
+
+There are two kinds of amounts of time, and they behave differently:
+
+- A `Duration` is an exact amount of time in hours, minutes and seconds. A day is always 24 hours. Use it for what a
+  stopwatch would measure, such as the length of a video or how long ago something was published.
+- A `Period` is an amount of years, months and days that follows the calendar. Use it for what a calendar would
+  measure, such as an age or "valid for 6 months".
+
+```typescript
+import { Duration, Instant, LocalDate, Period } from "/lib/time";
+
+const published = Instant.parse("2023-02-08T10:15:30Z");
+const now = Instant.parse("2023-02-08T11:45:30Z");
+const sincePublished = Duration.between(published, now);
+// sincePublished.toMinutes() = 90
+// sincePublished.toString() = "PT1H30M"
+
+const age = Period.between(LocalDate.parse("1990-05-17"), LocalDate.parse("2023-02-08"));
+// age.getYears() = 32
+```
+
+Both can be added to and subtracted from the date-time classes with `plus()` and `minus()`, and both can be parsed
+from ISO-8601 text such as `"PT1H30M"` and `"P1Y2M3D"`. A `Duration` can only be added to something with a time of
+day, and a `Period` only to something with a date.
+
+```typescript
+import { Duration, LocalDate, LocalDateTime, Period } from "/lib/time";
+
+const expires = LocalDate.parse("2023-01-31").plus(Period.ofMonths(1));
+// expires = "2023-02-28"
+
+const ends = LocalDateTime.parse("2023-02-08T23:15:30").plus(Duration.ofMinutes(90));
+// ends = "2023-02-09T00:45:30"
+```
+
+The difference between the two shows when the clocks change. Summer time in Oslo started on 26 March 2023, so that
+day was only 23 hours long:
+
+```typescript
+import { Duration, Period, ZonedDateTime } from "/lib/time";
+
+const dayBefore = ZonedDateTime.parse("2023-03-25T12:00:00+01:00[Europe/Oslo]");
+
+dayBefore.plus(Period.ofDays(1));   // "2023-03-26T12:00+02:00[Europe/Oslo]", the same time the next day
+dayBefore.plus(Duration.ofDays(1)); // "2023-03-26T13:00+02:00[Europe/Oslo]", exactly 24 hours later
+```
+
+`ChronoUnit` is the list of units, from `NANOS` to `MILLENNIA`. It counts whole units between two dates or times, and
+is used with `plus()`, `minus()`, `until()` and `truncatedTo()`.
+
+```typescript
+import { ChronoUnit, LocalDate, LocalDateTime } from "/lib/time";
+
+const daysUntilEvent = ChronoUnit.DAYS.between(LocalDate.parse("2023-02-08"), LocalDate.parse("2023-03-01"));
+// daysUntilEvent = 21
+
+const inThreeWeeks = LocalDate.parse("2023-02-08").plus(3, ChronoUnit.WEEKS);
+// inThreeWeeks = "2023-03-01"
+
+const startOfHour = LocalDateTime.parse("2023-02-08T10:15:30").truncatedTo(ChronoUnit.HOURS);
+// startOfHour = "2023-02-08T10:00"
+```
+
+### Formatting dates with `formatDate()`
+
+The utility function `formatDate()` formats a date in one call. It takes a
+[pattern](https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/format/DateTimeFormatter.html#patterns),
+and optionally a `locale` and a `timezoneId`.
 
 ```typescript
 import { formatDate } from "/lib/time";
 
 const today = formatDate({
   date: "2023-02-21",
-  pattern: "dd-MM-yyyy",
+  pattern: "EEEE d. MMMM yyyy",
   locale: "no"
 });
-// today = "21-02-2023"
+// today = "tirsdag 21. februar 2023"
 ```
-*Use `formatDate()` with a given timezoneId*
+
+*Use `timezoneId` to convert a point in time to a time zone:*
+
 ```typescript
 import { formatDate } from "/lib/time";
 
-const today = formatDate({
-  date: "2023-02-21",
-  pattern: "dd-MM-yyyy",
-  locale: "no",
+const time = formatDate({
+  date: "2023-02-21T12:15:30Z",
+  pattern: "dd.MM.yyyy HH:mm",
   timezoneId: "Europe/Oslo"
 });
-// today = "21-02-2023"
+// time = "21.02.2023 13:15"
 ```
 
+The `date` can be a JavaScript `Date` or a string, and `formatDate()` returns `undefined` if it is `undefined`, `null`
+or an empty string.
+
+| `date`                                             | Example                                  | Without `timezoneId`                 | With `timezoneId`          |
+|----------------------------------------------------|------------------------------------------|--------------------------------------|----------------------------|
+| `Date`                                             | `new Date()`                             | Shown in the time zone of the server | Converted to the time zone |
+| Date and time with `Z`, an offset or a zone id     | `"2023-02-21T12:15:30+01:00"`            | Shown as written                     | Converted to the time zone |
+| Date and time without an offset                    | `"2023-02-21T12:15:30"`                  | Shown as written                     | Shown as written           |
+| Date                                               | `"2023-02-21"`                           | Shown as written                     | Shown as written           |
+
+A `timezoneId` that is not a valid time zone falls back to the time zone of the server.
+
 *Example of using `Locale` in formatting a `LocalDateTime` and get a normalized timestamp :*
 ```typescript
 import { LocalDateTime, DateTimeFormatter, Locale } from "/lib/time";
@@ -107,7 +191,7 @@ const time = today.format(formatter);
 // time = "tirsdag 21. februar 2023 12:15:30"
 ```
 
-*Example of using hte `LanguageRange` utility to find the preferred locale among the ones supported by the application.*
+*Example of using the `LanguageRange` utility to find the preferred locale among the ones supported by the application.*
 
 ```typescript
 import { LanguageRange, Locale } from "/lib/time";
@@ -127,10 +211,32 @@ export function get(req: Request): Response {
 
 ```
 
-### Constants exposed from `"/lib/time"`
-The following classes is exposed/exported from `"/lib/time"`:
+### Lists and sets from Java
+
+Some methods return a Java collection instead of a JavaScript array. They are typed as `JavaList` and `JavaSet`:
+
+- A `JavaList`, such as the result of `LanguageRange.parse()` and `Locale.filterTags()`, can be read by index, has a
+  `length` and can be looped over with `forEach()`. It also has `size()`, `get()`, `contains()` and `isEmpty()`. Array
+  methods such as `map()` and `filter()` are not available on every script engine, so they are left out of the type.
+- A `JavaSet`, such as the result of `ZoneId.getAvailableZoneIds()`, has `size()`, `contains()`, `isEmpty()` and
+  `forEach()`. It has no order, so it can not be read by index.
+
+```typescript
+import { ZoneId } from "/lib/time";
+
+const isKnownTimeZone = ZoneId.getAvailableZoneIds().contains("Europe/Oslo");
+// isKnownTimeZone = true
+```
+
+### Exported from `"/lib/time"`
+
+The following classes are exported from `"/lib/time"`:
+
+* `ChronoUnit`
 * `DateTimeFormatter`
 * `DayOfWeek`
+* `Duration`
+* `FormatStyle`
 * `Instant`
 * `LanguageRange`
 * `LocalDate`
@@ -140,21 +246,41 @@ The following classes is exposed/exported from `"/lib/time"`:
 * `Month`
 * `OffsetDateTime`
 * `OffsetTime`
+* `Period`
+* `TextStyle`
 * `Year`
 * `ZonedDateTime`
 * `ZoneId`
 * `ZoneOffset`
 
-## Deploying
+Together with the function `formatDate()`, and the types `JavaList`, `JavaSet`, `MonthNumber`,
+`Temporal`, `TemporalAmount` and `TimeTemporal`.
+
+## Development
 
 ### Building
 
+Building requires Java 25, which is what Enonic XP 8 compiles against. Node.js is downloaded by Gradle, in the version
+given in *.nvmrc*.
+
 To build the project, run the following command
 
 ```bash
-enonic project build
+./gradlew build
 ```
 
+This checks the code with Biome and TypeScript, bundles it with tsdown, runs the tests and builds the jar.
+`enonic project build` does the same, when the project is linked to an XP 8 sandbox.
+
+### Testing
+
+The tests are JavaScript files in *src/test/resources/tests*. Every file named *\*Test.js* is picked up, and every
+function it exports with a name starting with `test` is run as a test of its own, so there is nothing to register.
+
+They run on both of the script engines of XP 8: `./gradlew test` uses Nashorn, and `./gradlew testGraalJS` uses
+GraalJS. The time zone of the tests is set to Europe/Oslo in *build.gradle*, so they give the same result on every
+machine.
+
 ### Deploying locally
 
 To deploy to a local sandbox, run the following command
@@ -163,14 +289,12 @@ To deploy to a local sandbox, run the following command
 enonic project deploy
 ```
 
-### Deploy to Maven
+### Releasing
 
-```bash
-./gradlew publish -P com.enonic.xp.app.production=true
-```
+Releases are made by GitHub Actions, using [Changesets](https://github.com/changesets/changesets).
 
-### Deploy to npm
-
-```bash
-npm publish
-```
+1. Describe your change by running `npx changeset`, and commit the file it creates together with the change.
+2. When the change is merged to `main`, a pull request named "Version Packages" is opened or updated. It bumps the
+   version and writes the changelog.
+3. Merging that pull request publishes the types to npm, tags the release on GitHub and publishes the jar to
+   [repo.itemtest.no](https://repo.itemtest.no/#/releases/no/item/lib-xp-time).

package/day-of-week.d.ts

@@ -1,8 +1,8 @@
-import { TextStyle } from "./format/text-style";
-import { Locale } from "./util";
+import type { TextStyle } from "./format/text-style";
+import type { Locale } from "./util";
 /**
  *  DayOfWeek is an enum representing the 7 days of the week - Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/DayOfWeek.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/DayOfWeek.html}
  */
 export declare const DayOfWeek: DayOfWeekConstructor;
 export type WeekDayNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7;

package/duration.d.ts

@@ -0,0 +1,85 @@
+import type { ChronoUnit } from "/lib/time";
+import type { TimeTemporal } from "/lib/time/temporal/temporal";
+/**
+ * A time-based amount of time, such as '34.5 seconds'.
+ *
+ * This class models a quantity or amount of time in terms of seconds and nanoseconds. A day is always exactly 24 hours.
+ * Use Period for an amount of time in years, months and days that follows the calendar.
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/Duration.html}
+ */
+export declare const Duration: DurationConstructor;
+export interface DurationConstructor {
+    ZERO: Duration;
+    between(startInclusive: TimeTemporal, endExclusive: TimeTemporal): Duration;
+    of(amount: number, unit: ChronoUnit): Duration;
+    ofDays(days: number): Duration;
+    ofHours(hours: number): Duration;
+    ofMillis(millis: number): Duration;
+    ofMinutes(minutes: number): Duration;
+    ofNanos(nanos: number): Duration;
+    ofSeconds(seconds: number): Duration;
+    ofSeconds(seconds: number, nanoAdjustment: number): Duration;
+    /**
+     * Parses an ISO-8601 duration, such as "PT1H30M" or "P2DT3H".
+     */
+    parse(text: string): Duration;
+}
+export interface Duration {
+    abs(): Duration;
+    compareTo(otherDuration: Duration): number;
+    dividedBy(divisor: number): Duration;
+    /**
+     * The number of whole times the other duration fits in this one
+     */
+    dividedBy(divisor: Duration): number;
+    equals(otherDuration: unknown): boolean;
+    getNano(): number;
+    getSeconds(): number;
+    hashCode(): number;
+    isNegative(): boolean;
+    isPositive(): boolean;
+    isZero(): boolean;
+    minus(duration: Duration): Duration;
+    minus(amountToSubtract: number, unit: ChronoUnit): Duration;
+    minusDays(daysToSubtract: number): Duration;
+    minusHours(hoursToSubtract: number): Duration;
+    minusMillis(millisToSubtract: number): Duration;
+    minusMinutes(minutesToSubtract: number): Duration;
+    minusNanos(nanosToSubtract: number): Duration;
+    minusSeconds(secondsToSubtract: number): Duration;
+    multipliedBy(multiplicand: number): Duration;
+    negated(): Duration;
+    plus(duration: Duration): Duration;
+    plus(amountToAdd: number, unit: ChronoUnit): Duration;
+    plusDays(daysToAdd: number): Duration;
+    plusHours(hoursToAdd: number): Duration;
+    plusMillis(millisToAdd: number): Duration;
+    plusMinutes(minutesToAdd: number): Duration;
+    plusNanos(nanosToAdd: number): Duration;
+    plusSeconds(secondsToAdd: number): Duration;
+    /**
+     * The whole duration in days, where a day is 24 hours
+     */
+    toDays(): number;
+    toDaysPart(): number;
+    /**
+     * The whole duration in hours. Use toHoursPart() for the hours left after the days are taken out.
+     */
+    toHours(): number;
+    toHoursPart(): number;
+    toMillis(): number;
+    toMillisPart(): number;
+    toMinutes(): number;
+    toMinutesPart(): number;
+    toNanos(): number;
+    toNanosPart(): number;
+    toSeconds(): number;
+    toSecondsPart(): number;
+    /**
+     * The ISO-8601 representation, such as "PT1H30M"
+     */
+    toString(): string;
+    truncatedTo(unit: ChronoUnit): Duration;
+    withNanos(nanoOfSecond: number): Duration;
+    withSeconds(seconds: number): Duration;
+}

package/format/date-time-formatter.d.ts

@@ -1,11 +1,13 @@
-import type { ZoneId, Locale } from "/lib/time";
+import type { Locale, ZoneId } from "/lib/time";
 import type { FormatStyle } from "/lib/time/format/format-style";
+import type { Temporal } from "/lib/time/temporal/temporal";
 /**
  * Formatter for printing and parsing date-time objects.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/format/DateTimeFormatter.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/format/DateTimeFormatter.html}
  */
 export declare const DateTimeFormatter: DateTimeFormatterConstructor;
 export interface DateTimeFormatter {
+    format(temporal: Temporal): string;
     getLocale(): Locale;
     getZone(): ZoneId;
     localizedBy(locale: Locale): DateTimeFormatter;
@@ -13,7 +15,6 @@ export interface DateTimeFormatter {
     withZone(zone: ZoneId): DateTimeFormatter;
 }
 export interface DateTimeFormatterConstructor {
-    new (): DateTimeFormatter;
     BASIC_ISO_DATE: DateTimeFormatter;
     ISO_DATE: DateTimeFormatter;
     ISO_DATE_TIME: DateTimeFormatter;
@@ -21,6 +22,8 @@ export interface DateTimeFormatterConstructor {
     ISO_LOCAL_DATE: DateTimeFormatter;
     ISO_LOCAL_DATE_TIME: DateTimeFormatter;
     ISO_LOCAL_TIME: DateTimeFormatter;
+    ISO_OFFSET_DATE: DateTimeFormatter;
+    ISO_OFFSET_DATE_TIME: DateTimeFormatter;
     ISO_OFFSET_TIME: DateTimeFormatter;
     ISO_ORDINAL_DATE: DateTimeFormatter;
     ISO_TIME: DateTimeFormatter;

package/format/format-style.d.ts

@@ -2,7 +2,7 @@
  * Enumeration of the style of a localized date, time or date-time formatter.
  *
  * These styles are used when obtaining a date-time style from configuration. See DateTimeFormatter and DateTimeFormatterBuilder for usage.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/format/FormatStyle.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/format/FormatStyle.html}
  */
 export declare const FormatStyle: FormatStyleConstructor;
 export interface FormatStyleConstructor {

package/format/text-style.d.ts

@@ -6,7 +6,7 @@
  * The difference between the three sizes is obvious in most languages. For example, in English the 'full' month is 'January', the 'short' month is 'Jan' and the 'narrow' month is 'J'. Note that the narrow size is often not unique. For example, 'January', 'June' and 'July' all have the 'narrow' text 'J'.
  *
  * The difference between the 'standard' and 'stand-alone' forms is trickier to describe as there is no difference in English. However, in other languages there is a difference in the word used when the text is used alone, as opposed to in a complete date. For example, the word used for a month when used alone in a date picker is different to the word used for month in association with a day and year in a date.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/format/TextStyle.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/format/TextStyle.html}
  */
 export declare const TextStyle: TextStyleConstructor;
 export interface TextStyleConstructor {

package/index.d.ts

@@ -1,22 +1,26 @@
 export { DayOfWeek } from "/lib/time/day-of-week";
-export { LocalDateTime } from "/lib/time/local-date-time";
-export { ZonedDateTime } from "/lib/time/zoned-date-time";
-export { Locale, LanguageRange } from "/lib/time/util";
+export { Duration } from "/lib/time/duration";
 export { DateTimeFormatter } from "/lib/time/format/date-time-formatter";
-export { TextStyle } from "/lib/time/format/text-style";
 export { FormatStyle } from "/lib/time/format/format-style";
+export { TextStyle } from "/lib/time/format/text-style";
 export { Instant } from "/lib/time/instant";
 export { LocalDate } from "/lib/time/local-date";
+export { LocalDateTime } from "/lib/time/local-date-time";
 export { LocalTime } from "/lib/time/local-time";
 export { Month, type MonthNumber } from "/lib/time/month";
 export { OffsetDateTime } from "/lib/time/offset-date-time";
 export { OffsetTime } from "/lib/time/offset-time";
+export { Period } from "/lib/time/period";
+export { ChronoUnit } from "/lib/time/temporal/chrono-unit";
+export type { Temporal, TemporalAmount, TimeTemporal } from "/lib/time/temporal/temporal";
+export { type JavaList, type JavaSet, LanguageRange, Locale } from "/lib/time/util";
 export { Year } from "/lib/time/year";
 export { ZoneId } from "/lib/time/zone-id";
 export { ZoneOffset } from "/lib/time/zone-offset";
+export { ZonedDateTime } from "/lib/time/zoned-date-time";
 /**
  * Format a date to a string
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/format/DateTimeFormatter.html#patterns}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/format/DateTimeFormatter.html#patterns}
  *
  * @param date The date as a string
  * @param pattern The shape of the output string

package/instant.d.ts

@@ -1,9 +1,10 @@
-import type { ZoneOffset, OffsetDateTime, ZoneId, ZonedDateTime } from "/lib/time";
+import type { ChronoUnit, Duration, OffsetDateTime, ZonedDateTime, ZoneId, ZoneOffset } from "/lib/time";
+import type { Temporal } from "/lib/time/temporal/temporal";
 /**
  * An instantaneous point on the time-line.
  *
  * This class models a single instantaneous point on the time-line. This might be used to record event time-stamps in the application.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/Instant.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/Instant.html}
  */
 export declare const Instant: InstantConstructor;
 export interface InstantConstructor {
@@ -14,6 +15,18 @@ export interface InstantConstructor {
     parse(text: string): Instant;
 }
 export interface Instant {
+    minus(amountToSubtract: Duration): Instant;
+    minus(amountToSubtract: number, unit: ChronoUnit): Instant;
+    plus(amountToAdd: Duration): Instant;
+    plus(amountToAdd: number, unit: ChronoUnit): Instant;
+    /**
+     * Sets every unit smaller than the given one to zero, so truncating to hours gives the start of the hour
+     */
+    truncatedTo(unit: ChronoUnit): Instant;
+    /**
+     * The number of whole units until the other one. It is negative if the other one is earlier.
+     */
+    until(endExclusive: Temporal, unit: ChronoUnit): number;
     atOffset(offset: ZoneOffset): OffsetDateTime;
     atZone(zone: ZoneId): ZonedDateTime;
     compareTo(otherInstant: Instant): number;

package/local-date-time.d.ts

@@ -1,7 +1,8 @@
-import type { DateTimeFormatter, Month, LocalDate, LocalTime, ZoneOffset, Instant, ZoneId, DayOfWeek, OffsetDateTime, ZonedDateTime } from "/lib/time";
+import type { ChronoUnit, DateTimeFormatter, DayOfWeek, Instant, LocalDate, LocalTime, Month, OffsetDateTime, ZonedDateTime, ZoneId, ZoneOffset } from "/lib/time";
+import type { Temporal, TemporalAmount } from "/lib/time/temporal/temporal";
 /**
  * LocalDateTime is an immutable date-time object that represents a date-time
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/LocalDateTime.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/LocalDateTime.html}
  */
 export declare const LocalDateTime: LocalDateTimeConstructor;
 export interface LocalDateTimeConstructor {
@@ -14,14 +15,26 @@ export interface LocalDateTimeConstructor {
     of(year: number, month: number, dayOfMonth: number, hour: number, minute: number): LocalDateTime;
     of(year: number, month: number, dayOfMonth: number, hour: number, minute: number, second: number): LocalDateTime;
     of(year: number, month: number, dayOfMonth: number, hour: number, minute: number, second: number, nanoOfSecond: number): LocalDateTime;
-    of(year: number, month: Month, dayOfMonth: number, hour: number, minute: number, second: number, nanoOfSecond: number): LocalDateTime;
-    of(year: number, month: Month, dayOfMonth: number, hour: number, minute: number, second: number, nanoOfSecond: number): LocalDateTime;
+    of(year: number, month: Month, dayOfMonth: number, hour: number, minute: number): LocalDateTime;
+    of(year: number, month: Month, dayOfMonth: number, hour: number, minute: number, second: number): LocalDateTime;
     of(year: number, month: Month, dayOfMonth: number, hour: number, minute: number, second: number, nanoOfSecond: number): LocalDateTime;
     of(date: LocalDate, time: LocalTime): LocalDateTime;
     ofEpochSecond(epochSecond: number, nanoOfSecond: number, offset: ZoneOffset): LocalDateTime;
     ofInstant(instant: Instant, zone: ZoneId): LocalDateTime;
 }
 export interface LocalDateTime {
+    minus(amountToSubtract: TemporalAmount): LocalDateTime;
+    minus(amountToSubtract: number, unit: ChronoUnit): LocalDateTime;
+    plus(amountToAdd: TemporalAmount): LocalDateTime;
+    plus(amountToAdd: number, unit: ChronoUnit): LocalDateTime;
+    /**
+     * Sets every unit smaller than the given one to zero, so truncating to hours gives the start of the hour
+     */
+    truncatedTo(unit: ChronoUnit): LocalDateTime;
+    /**
+     * The number of whole units until the other one. It is negative if the other one is earlier.
+     */
+    until(endExclusive: Temporal, unit: ChronoUnit): number;
     atOffset(offset: ZoneOffset): OffsetDateTime;
     atZone(zone: ZoneId): ZonedDateTime;
     format(formatter: DateTimeFormatter): string;

package/local-date.d.ts

@@ -1,9 +1,10 @@
-import type { DateTimeFormatter, ZoneId, Month, Instant, LocalDateTime, ZonedDateTime, LocalTime, OffsetTime, OffsetDateTime, DayOfWeek, ZoneOffset } from "/lib/time";
+import type { ChronoUnit, DateTimeFormatter, DayOfWeek, Instant, LocalDateTime, LocalTime, Month, OffsetDateTime, OffsetTime, Period, ZonedDateTime, ZoneId, ZoneOffset } from "/lib/time";
+import type { Temporal } from "/lib/time/temporal/temporal";
 /**
  * A date without a time-zone in the ISO-8601 calendar system, such as 2007-12-03.
  *
  * LocalDate is an immutable date-time object that represents a date, often viewed as year-month-day. Other date fields, such as day-of-year, day-of-week and week-of-year, can also be accessed. For example, the value "2nd October 2007" can be stored in a LocalDate.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/LocalDate.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/LocalDate.html}
  */
 export declare const LocalDate: LocalDateConstructor;
 interface LocalDateConstructor {
@@ -21,6 +22,18 @@ interface LocalDateConstructor {
     parse(text: string, formatter: DateTimeFormatter): LocalDate;
 }
 export interface LocalDate {
+    minus(amountToSubtract: Period): LocalDate;
+    minus(amountToSubtract: number, unit: ChronoUnit): LocalDate;
+    plus(amountToAdd: Period): LocalDate;
+    plus(amountToAdd: number, unit: ChronoUnit): LocalDate;
+    /**
+     * The years, months and days until the other date
+     */
+    until(endDateExclusive: LocalDate): Period;
+    /**
+     * The number of whole units until the other one. It is negative if the other one is earlier.
+     */
+    until(endExclusive: Temporal, unit: ChronoUnit): number;
     atStartOfDay(): LocalDateTime;
     atStartOfDay(zone: ZoneId): ZonedDateTime;
     atTime(hour: number, minute: number): LocalDateTime;

package/local-time.d.ts

@@ -1,9 +1,10 @@
-import type { ZoneId, Instant, DateTimeFormatter, LocalDateTime, LocalDate, ZoneOffset, OffsetTime } from "/lib/time";
+import type { ChronoUnit, DateTimeFormatter, Duration, Instant, LocalDate, LocalDateTime, OffsetTime, ZoneId, ZoneOffset } from "/lib/time";
+import type { Temporal } from "/lib/time/temporal/temporal";
 /**
  * A time without a time-zone in the ISO-8601 calendar system, such as 10:15:30.
  *
  * LocalTime is an immutable date-time object that represents a time, often viewed as hour-minute-second. Time is represented to nanosecond precision. For example, the value "13:45.30.123456789" can be stored in a LocalTime.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/LocalTime.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/LocalTime.html}
  */
 export declare const LocalTime: LocalTimeConstructor;
 export interface LocalTimeConstructor {
@@ -23,6 +24,18 @@ export interface LocalTimeConstructor {
     parse(text: string, formatter: DateTimeFormatter): LocalTime;
 }
 export interface LocalTime {
+    minus(amountToSubtract: Duration): LocalTime;
+    minus(amountToSubtract: number, unit: ChronoUnit): LocalTime;
+    plus(amountToAdd: Duration): LocalTime;
+    plus(amountToAdd: number, unit: ChronoUnit): LocalTime;
+    /**
+     * Sets every unit smaller than the given one to zero, so truncating to hours gives the start of the hour
+     */
+    truncatedTo(unit: ChronoUnit): LocalTime;
+    /**
+     * The number of whole units until the other one. It is negative if the other one is earlier.
+     */
+    until(endExclusive: Temporal, unit: ChronoUnit): number;
     atDate(date: LocalDate): LocalDateTime;
     atOffset(offset: ZoneOffset): OffsetTime;
     compareTo(other: LocalTime): number;

package/month.d.ts

@@ -4,7 +4,7 @@ import type { Locale } from "./util";
  * A month-of-year, such as 'July'.
  *
  * Month is an enum representing the 12 months of the year - January, February, March, April, May, June, July, August, September, October, November and December.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/Month.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/Month.html}
  */
 export declare const Month: MonthConstructor;
 export type MonthNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;

package/offset-date-time.d.ts

@@ -1,9 +1,10 @@
-import type { ZoneId, ZoneOffset, LocalDate, LocalTime, LocalDateTime, Instant, DateTimeFormatter, ZonedDateTime, DayOfWeek, Month, OffsetTime } from "/lib/time";
+import type { ChronoUnit, DateTimeFormatter, DayOfWeek, Instant, LocalDate, LocalDateTime, LocalTime, Month, OffsetTime, ZonedDateTime, ZoneId, ZoneOffset } from "/lib/time";
+import type { Temporal, TemporalAmount } from "/lib/time/temporal/temporal";
 /**
  * A date-time with an offset from UTC/Greenwich in the ISO-8601 calendar system, such as 2007-12-03T10:15:30+01:00.
  *
  * OffsetDateTime is an immutable representation of a date-time with an offset. This class stores all date and time fields, to a precision of nanoseconds, as well as the offset from UTC/Greenwich. For example, the value "2nd October 2007 at 13:45:30.123456789 +02:00" can be stored in an OffsetDateTime.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/OffsetDateTime.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/OffsetDateTime.html}
  */
 export declare const OffsetDateTime: OffsetDateTimeConstructor;
 export interface OffsetDateTimeConstructor {
@@ -19,6 +20,18 @@ export interface OffsetDateTimeConstructor {
     parse(text: string, formatter: DateTimeFormatter): OffsetDateTime;
 }
 export interface OffsetDateTime {
+    minus(amountToSubtract: TemporalAmount): OffsetDateTime;
+    minus(amountToSubtract: number, unit: ChronoUnit): OffsetDateTime;
+    plus(amountToAdd: TemporalAmount): OffsetDateTime;
+    plus(amountToAdd: number, unit: ChronoUnit): OffsetDateTime;
+    /**
+     * Sets every unit smaller than the given one to zero, so truncating to hours gives the start of the hour
+     */
+    truncatedTo(unit: ChronoUnit): OffsetDateTime;
+    /**
+     * The number of whole units until the other one. It is negative if the other one is earlier.
+     */
+    until(endExclusive: Temporal, unit: ChronoUnit): number;
     atZoneSameInstant(zone: ZoneId): ZonedDateTime;
     atZoneSimilarLocal(zone: ZoneId): ZonedDateTime;
     compareTo(other: OffsetDateTime): number;

package/offset-time.d.ts

@@ -1,9 +1,10 @@
-import type { ZoneId, ZoneOffset, LocalDate, LocalTime, Instant, DateTimeFormatter, OffsetDateTime } from "/lib/time";
+import type { ChronoUnit, DateTimeFormatter, Duration, Instant, LocalDate, LocalTime, OffsetDateTime, ZoneId, ZoneOffset } from "/lib/time";
+import type { Temporal } from "/lib/time/temporal/temporal";
 /**
  * A time without a time-zone in the ISO-8601 calendar system, such as 10:15:30.
  *
  * LocalTime is an immutable date-time object that represents a time, often viewed as hour-minute-second. Time is represented to nanosecond precision. For example, the value "13:45.30.123456789" can be stored in a LocalTime.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/OffsetTime.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/OffsetTime.html}
  */
 export declare const OffsetTime: OffsetTimeConstructor;
 export interface OffsetTimeConstructor {
@@ -18,6 +19,18 @@ export interface OffsetTimeConstructor {
     parse(text: string, formatter: DateTimeFormatter): OffsetTime;
 }
 export interface OffsetTime {
+    minus(amountToSubtract: Duration): OffsetTime;
+    minus(amountToSubtract: number, unit: ChronoUnit): OffsetTime;
+    plus(amountToAdd: Duration): OffsetTime;
+    plus(amountToAdd: number, unit: ChronoUnit): OffsetTime;
+    /**
+     * Sets every unit smaller than the given one to zero, so truncating to hours gives the start of the hour
+     */
+    truncatedTo(unit: ChronoUnit): OffsetTime;
+    /**
+     * The number of whole units until the other one. It is negative if the other one is earlier.
+     */
+    until(endExclusive: Temporal, unit: ChronoUnit): number;
     atDate(date: LocalDate): OffsetDateTime;
     compareTo(other: OffsetTime): number;
     format(formatter: DateTimeFormatter): string;

package/package.json

@@ -1,39 +1,40 @@
 {
   "name": "@item-enonic-types/lib-time",
-  "version": "1.6.1",
+  "version": "2.0.0",
   "description": "Type definitions for lib-time",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ItemConsulting/lib-xp-time.git"
+  },
   "files": [
     "*.d.ts",
     "format/*.d.ts",
+    "temporal/*.d.ts",
     "tsconfig.json"
   ],
   "devDependencies": {
-    "@changesets/cli": "^2.29.8",
-    "@item-enonic-types/lib-testing": "^7.13.0",
-    "@swc/core": "^1.15.8",
-    "@types/node": "^25.0.3",
-    "eslint": "^9.39.2",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-plugin-prettier": "^5.5.4",
-    "concurrently": "^9.2.1",
-    "glob": "^13.0.0",
-    "prettier": "^3.7.4",
-    "tsup": "^8.5.1",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.52.0"
+    "@biomejs/biome": "^2.5.15",
+    "@changesets/cli": "^3.0.3",
+    "@item-enonic-types/lib-testing": "^8.0.0",
+    "@swc/core": "^1.16.18",
+    "@types/node": "^26.6.5",
+    "concurrently": "^10.0.6",
+    "tsdown": "^0.23.1",
+    "typescript": "^7.0.2"
   },
   "dependencies": {
     "@item-enonic-types/nashorn-env": "^0.0.2"
   },
   "scripts": {
-    "build": "node tsup/anyServerFiles.js && npx tsup -d build/resources/main",
+    "build": "tsdown",
     "check": "concurrently -c auto -g --timings npm:check:types npm:lint",
-    "check:types": "node tsup/anyServerFiles.js && npx tsc --noEmit -p src/main/resources/tsconfig.json || exit 0",
-    "lint": "eslint --cache \"src/main/resources/**/*.ts\"",
+    "check:types": "tsc --noEmit -p src/main/resources/tsconfig.json",
+    "lint": "biome ci",
+    "lint:fix": "biome check --write",
     "prepublishOnly": "tsc --project src/main/resources/tsconfig.json --declarationDir build/types --emitDeclarationOnly true --declaration true && cp -r ./build/types/* .",
-    "postpublish": "rm ./*.d.ts && rm -r ./format",
-    "release": "npm run build",
-    "versioning": "npx changeset version && npm i --package-lock-only && NEW_VERSION=$(node -p \"require('./package.json').version\") && sed -i \"s/version.*/version = ${NEW_VERSION}/\" gradle.properties"
+    "postpublish": "rm ./*.d.ts && rm -r ./format ./temporal",
+    "release": "changeset publish",
+    "versioning": "changeset version && npm i --package-lock-only && node .changeset/gradle-version.mjs"
   }
 }

package/period.d.ts

@@ -0,0 +1,53 @@
+import type { LocalDate } from "/lib/time";
+/**
+ * A date-based amount of time in the ISO-8601 calendar system, such as '2 years, 3 months and 4 days'.
+ *
+ * This class models a quantity or amount of time in terms of years, months and days. How long that is depends on the
+ * date it is added to: a month can be 28 to 31 days. Use Duration for an exact amount of time.
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/Period.html}
+ */
+export declare const Period: PeriodConstructor;
+export interface PeriodConstructor {
+    ZERO: Period;
+    between(startDateInclusive: LocalDate, endDateExclusive: LocalDate): Period;
+    of(years: number, months: number, days: number): Period;
+    ofDays(days: number): Period;
+    ofMonths(months: number): Period;
+    ofWeeks(weeks: number): Period;
+    ofYears(years: number): Period;
+    /**
+     * Parses an ISO-8601 period, such as "P1Y2M3D" or "P2W".
+     */
+    parse(text: string): Period;
+}
+export interface Period {
+    equals(otherPeriod: unknown): boolean;
+    getDays(): number;
+    getMonths(): number;
+    getYears(): number;
+    hashCode(): number;
+    isNegative(): boolean;
+    isZero(): boolean;
+    minus(amountToSubtract: Period): Period;
+    minusDays(daysToSubtract: number): Period;
+    minusMonths(monthsToSubtract: number): Period;
+    minusYears(yearsToSubtract: number): Period;
+    multipliedBy(scalar: number): Period;
+    negated(): Period;
+    /**
+     * Moves whole years out of the months, so "P15M" becomes "P1Y3M". The days are left as they are.
+     */
+    normalized(): Period;
+    plus(amountToAdd: Period): Period;
+    plusDays(daysToAdd: number): Period;
+    plusMonths(monthsToAdd: number): Period;
+    plusYears(yearsToAdd: number): Period;
+    /**
+     * The ISO-8601 representation, such as "P1Y2M3D"
+     */
+    toString(): string;
+    toTotalMonths(): number;
+    withDays(days: number): Period;
+    withMonths(months: number): Period;
+    withYears(years: number): Period;
+}

package/temporal/chrono-unit.d.ts

@@ -0,0 +1,41 @@
+import type { Duration } from "/lib/time";
+import type { Temporal } from "/lib/time/temporal/temporal";
+/**
+ * A standard set of date periods units.
+ *
+ * This set of units provide unit-based access to manipulate a date, time or date-time. For example,
+ * `ChronoUnit.DAYS.between(start, end)` gives the number of whole days between two dates.
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/temporal/ChronoUnit.html}
+ */
+export declare const ChronoUnit: ChronoUnitConstructor;
+export interface ChronoUnitConstructor {
+    NANOS: ChronoUnit;
+    MICROS: ChronoUnit;
+    MILLIS: ChronoUnit;
+    SECONDS: ChronoUnit;
+    MINUTES: ChronoUnit;
+    HOURS: ChronoUnit;
+    HALF_DAYS: ChronoUnit;
+    DAYS: ChronoUnit;
+    WEEKS: ChronoUnit;
+    MONTHS: ChronoUnit;
+    YEARS: ChronoUnit;
+    DECADES: ChronoUnit;
+    CENTURIES: ChronoUnit;
+    MILLENNIA: ChronoUnit;
+    ERAS: ChronoUnit;
+    FOREVER: ChronoUnit;
+    valueOf(name: string): ChronoUnit;
+    values(): ChronoUnit[];
+}
+export interface ChronoUnit {
+    /**
+     * The number of whole units between the two. It is negative if the end is before the start.
+     */
+    between(startInclusive: Temporal, endExclusive: Temporal): number;
+    getDuration(): Duration;
+    isDateBased(): boolean;
+    isDurationEstimated(): boolean;
+    isTimeBased(): boolean;
+    toString(): string;
+}

package/temporal/temporal.d.ts

@@ -0,0 +1,15 @@
+import type { Duration, Instant, LocalDate, LocalDateTime, LocalTime, OffsetDateTime, OffsetTime, Period, Year, ZonedDateTime } from "/lib/time";
+/**
+ * The date-time objects in this library: the ones that can be formatted, compared and have time added to them.
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/temporal/Temporal.html}
+ */
+export type Temporal = Instant | LocalDate | LocalDateTime | LocalTime | OffsetDateTime | OffsetTime | Year | ZonedDateTime;
+/**
+ * The date-time objects that have a time of day, which is what an exact amount of time can be measured between.
+ */
+export type TimeTemporal = Instant | LocalDateTime | LocalTime | OffsetDateTime | OffsetTime | ZonedDateTime;
+/**
+ * An amount of time, that can be added to or subtracted from a date-time object.
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/temporal/TemporalAmount.html}
+ */
+export type TemporalAmount = Duration | Period;

package/tsconfig.json

@@ -1,18 +1,18 @@
 {
-  "include": [
-    "**/*.ts"
-  ],
+  "include": ["**/*.ts", "**/*.mts"],
   "exclude": [
     "**/*.d.ts",
-    "src/**/*.*", // Avoid Enonic XP source files
+    "src/**/*.*" // Avoid Enonic XP source files
   ],
 
   "compilerOptions": {
+    "strict": true,
     "lib": [
       "es2023" // string.replaceAll
     ],
-    "types": [
-      "node"
-    ],
-  },
+    "types": ["node"],
+    "skipLibCheck": true,
+    "module": "preserve",
+    "moduleResolution": "bundler"
+  }
 }

package/util.d.ts

@@ -1,12 +1,38 @@
 /**
  * A Locale object represents a specific geographical, political, or cultural region.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/Locale.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/util/Locale.html}
  */
 export declare const Locale: LocaleConstructor;
 /**
  * A LanguageRange can be used to parse `req.headers["Accept-Language"]` to determine the best matching language.
  */
 export declare const LanguageRange: LanguageRangeConstructor;
+/**
+ * A `java.util.List` returned from Java. It can be read by index and looped over like an array, but it is not a
+ * JavaScript array: methods such as `map()` and `filter()` are not available on every script engine.
+ */
+export interface JavaList<T> {
+    readonly [index: number]: T;
+    readonly length: number;
+    forEach(callback: (value: T) => void): void;
+    contains(value: T): boolean;
+    get(index: number): T;
+    isEmpty(): boolean;
+    size(): number;
+}
+/**
+ * A `java.util.Set` returned from Java. It has no order, so it can not be read by index.
+ */
+export interface JavaSet<T> {
+    forEach(callback: (value: T) => void): void;
+    contains(value: T): boolean;
+    isEmpty(): boolean;
+    size(): number;
+}
+/**
+ * Where Java takes a list of language ranges, both a JavaScript array and the list from `LanguageRange.parse()` work.
+ */
+export type LanguagePriorityList = LanguageRange[] | JavaList<LanguageRange>;
 export interface LocaleConstructor {
     new (language: string, country?: string, variant?: string): Locale;
     CANADA: Locale;
@@ -31,19 +57,18 @@ export interface LocaleConstructor {
     UK: Locale;
     UNICODE_LOCALE_EXTENSION: Locale;
     US: Locale;
-    filter(priorityList: LanguageRange[], locales: Locale[]): Locale[];
-    filterTags(priorityList: LanguageRange[], tags: string[]): string[];
+    filter(priorityList: LanguagePriorityList, locales: Locale[]): JavaList<Locale>;
+    filterTags(priorityList: LanguagePriorityList, tags: string[]): JavaList<string>;
     forLanguageTag(languageTag: string): Locale;
     getAvailableLocales(): Locale[];
     getDefault(): Locale;
     getISOCountries(): string[];
     getISOLanguages(): string[];
-    lookup(priorityList: LanguageRange[], locales: Locale[]): Locale;
-    lookupTag(priorityList: LanguageRange[], tags: string[]): Locale;
+    lookup(priorityList: LanguagePriorityList, locales: Locale[]): Locale | null;
+    lookupTag(priorityList: LanguagePriorityList, tags: string[]): string | null;
     setDefault(newLocale: Locale): void;
 }
 export interface Locale {
-    getSubLocale(): string;
     getCountry(): string;
     getDisplayCountry(): string;
     getDisplayLanguage(): string;
@@ -73,9 +98,9 @@ interface LanguageRangeConstructor {
     new (range: string, weight?: number): LanguageRange;
     MAX_WEIGHT: number;
     MIN_WEIGHT: number;
-    mapEquivalents(priorityList: LanguageRange[], map: Record<string, string[]>): LanguageRange[];
-    parse(ranges: string): LanguageRange[];
-    parse(ranges: string, map: Record<string, string[]>): LanguageRange[];
+    mapEquivalents(priorityList: LanguagePriorityList, map: Record<string, string[]>): JavaList<LanguageRange>;
+    parse(ranges: string): JavaList<LanguageRange>;
+    parse(ranges: string, map: Record<string, string[]>): JavaList<LanguageRange>;
 }
 export interface LanguageRange {
     getRange(): string;

package/year.d.ts

@@ -1,10 +1,10 @@
-import type { ZoneId } from "./zone-id";
-import type { LocalDate } from "./local-date";
 import type { DateTimeFormatter } from "./format/date-time-formatter";
+import type { LocalDate } from "./local-date";
+import type { ZoneId } from "./zone-id";
 /**
  * A year in the ISO-8601 calendar system, such as 2007.
  * Year is an immutable date-time object that represents a year. Any field that can be derived from a year can be obtained.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/Year.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/Year.html}
  */
 export declare const Year: YearConstructor;
 export interface YearConstructor {
@@ -20,7 +20,7 @@ export interface Year {
     toString(): string;
     hashCode(): number;
     atDay(dayOfYear: number): LocalDate;
-    compareTo(other: Year): boolean;
+    compareTo(other: Year): number;
     format(formatter: DateTimeFormatter): string;
     isAfter(other: Year): boolean;
     isBefore(other: Year): boolean;

package/zone-id.d.ts

@@ -1,12 +1,13 @@
 import type { ZoneOffset } from "/lib/time";
+import type { JavaSet } from "/lib/time/util";
 /**
  * A time-zone ID, such as Europe/Paris.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/ZoneId.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/ZoneId.html}
  */
 export declare const ZoneId: ZoneIdConstructor;
 export interface ZoneIdConstructor {
     SHORT_IDS: Record<string, string>;
-    getAvailableZoneIds(): ReadonlyArray<string>;
+    getAvailableZoneIds(): JavaSet<string>;
     of(zoneId: string): ZoneId;
     of(zoneId: string, aliasMap: Record<string, string>): ZoneId;
     ofOffset(prefix: string, offset: ZoneOffset): ZoneId;

package/zone-offset.d.ts

@@ -2,7 +2,7 @@
  * A time-zone offset from Greenwich/UTC, such as +02:00.
  *
  * A time-zone offset is the amount of time that a time-zone differs from Greenwich/UTC. This is usually a fixed number of hours and minutes.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/ZoneOffset.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/ZoneOffset.html}
  */
 export declare const ZoneOffset: ZoneOffsetConstructor;
 export interface ZoneOffsetConstructor {

package/zoned-date-time.d.ts

@@ -1,7 +1,8 @@
-import type { DateTimeFormatter, ZoneId, ZoneOffset, LocalDate, LocalTime, LocalDateTime, Instant, OffsetDateTime, DayOfWeek, Month } from "/lib/time";
+import type { ChronoUnit, DateTimeFormatter, DayOfWeek, Instant, LocalDate, LocalDateTime, LocalTime, Month, OffsetDateTime, ZoneId, ZoneOffset } from "/lib/time";
+import type { Temporal, TemporalAmount } from "/lib/time/temporal/temporal";
 /**
  * ZonedDateTime is an immutable representation of a date-time with a time-zone.
- * @see {@link https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/time/ZonedDateTime.html}
+ * @see {@link https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/time/ZonedDateTime.html}
  */
 export declare const ZonedDateTime: ZonedDateTimeConstructor;
 export interface ZonedDateTimeConstructor {
@@ -18,6 +19,18 @@ export interface ZonedDateTimeConstructor {
     parse(text: string, formatter: DateTimeFormatter): ZonedDateTime;
 }
 export interface ZonedDateTime {
+    minus(amountToSubtract: TemporalAmount): ZonedDateTime;
+    minus(amountToSubtract: number, unit: ChronoUnit): ZonedDateTime;
+    plus(amountToAdd: TemporalAmount): ZonedDateTime;
+    plus(amountToAdd: number, unit: ChronoUnit): ZonedDateTime;
+    /**
+     * Sets every unit smaller than the given one to zero, so truncating to hours gives the start of the hour
+     */
+    truncatedTo(unit: ChronoUnit): ZonedDateTime;
+    /**
+     * The number of whole units until the other one. It is negative if the other one is earlier.
+     */
+    until(endExclusive: Temporal, unit: ChronoUnit): number;
     format(formatter: DateTimeFormatter): string;
     getDayOfMonth(): number;
     getDayOfWeek(): DayOfWeek;