@item-enonic-types/lib-time 0.1.1 → 1.0.0

package/README.md

@@ -19,7 +19,7 @@ repositories {
 }
 
 dependencies {
-  include "no.item:lib-xp-time:0.1.0"
+  include "no.item:lib-xp-time:1.0.0"
 }
 ```
 
@@ -54,9 +54,11 @@ You can import `java.time` and  `java.time.format` classes from `"/lib/time"`.
 import { LocalDateTime, DateTimeFormatter } from "/lib/time";
 
 const today = LocalDateTime.parse("2023-02-21T12:15:30");
-const inThreeWeeks = today.plusWeeks(3);
-const dateStr = inThreeWeeks.format(DateTimeFormatter.ofPattern("dd-MM-yyyy hh:mm:ss"));
-// dateStr = "14-03-2023 12:15:30"
+const formatter = DateTimeFormatter.ofPattern("dd.MM hh:mm")
+const inThreeWeeksStr = today
+  .plusWeeks(3)
+  .format(formatter);
+// inThreeWeeksStr = "14.03 12:15"
 ```
 
 *Example of doing time math using a `ZonedDateTime`:*
@@ -83,6 +85,16 @@ const today = t.formatDate({
 // today = "21-02-2023"
 ```
 
+*Example of using `Locale` in formatting a `LocalDateTime` and get a normalized timestamp :*
+```typescript
+import { LocalDateTime, DateTimeFormatter, Locale } from "/lib/time";
+
+const today = LocalDateTime.parse("2023-02-21T12:15:30");
+const formatter = DateTimeFormatter.ofPattern("EEEE d. MMMM yyyy hh:mm:ss", new Locale("no"));
+const time = today.format(formatter);
+// time = "tirsdag 21. februar 2023 12:15:30"
+```
+
 ### Constants exposed from `"/lib/time"`
 The following classes is exposed/exported from `"/lib/time"`:
 * `DateTimeFormatter`

package/day-of-week.d.ts

@@ -1,2 +1,13 @@
-export const __esModule: boolean;
-export const DayOfWeek: any;
+/**
+ *  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}
+ */
+export declare const DayOfWeek: DayOfWeekConstructor;
+export type WeekDayNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+export interface DayOfWeekConstructor {
+    of(dayOfWeek: WeekDayNumber): DayOfWeek;
+}
+export interface DayOfWeek {
+    getValue(): WeekDayNumber;
+    toString(): string;
+}

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

@@ -1,2 +1,31 @@
-export const __esModule: boolean;
-export const DateTimeFormatter: any;
+import type { ZoneId, Locale } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const DateTimeFormatter: DateTimeFormatterConstructor;
+export interface DateTimeFormatter {
+    getLocale(): Locale;
+    getZone(): ZoneId;
+    localizedBy(locale: Locale): DateTimeFormatter;
+    withLocale(locale: Locale): DateTimeFormatter;
+    withZone(zone: ZoneId): DateTimeFormatter;
+}
+export interface DateTimeFormatterConstructor {
+    new (): DateTimeFormatter;
+    BASIC_ISO_DATE: DateTimeFormatter;
+    ISO_DATE: DateTimeFormatter;
+    ISO_DATE_TIME: DateTimeFormatter;
+    ISO_INSTANT: DateTimeFormatter;
+    ISO_LOCAL_DATE: DateTimeFormatter;
+    ISO_LOCAL_DATE_TIME: DateTimeFormatter;
+    ISO_LOCAL_TIME: DateTimeFormatter;
+    ISO_OFFSET_TIME: DateTimeFormatter;
+    ISO_ORDINAL_DATE: DateTimeFormatter;
+    ISO_TIME: DateTimeFormatter;
+    ISO_WEEK_DATE: DateTimeFormatter;
+    ISO_ZONED_DATE_TIME: DateTimeFormatter;
+    RFC_1123_DATE_TIME: DateTimeFormatter;
+    ofPattern(pattern: string): DateTimeFormatter;
+    ofPattern(pattern: string, locale: Locale): DateTimeFormatter;
+}

package/index.d.ts

@@ -1,225 +1,33 @@
-declare const _exports: {
-    readonly DayOfWeek: any;
-    readonly __esModule: boolean;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly DateTimeFormatter: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly Instant: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly LocalDate: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly LocalDateTime: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly LocalTime: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly Month: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly OffsetDateTime: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly OffsetTime: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly Locale: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    /***/ readonly ZoneId: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly ZoneOffset: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly ZonedDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    formatDate: (_a: any) => any;
-} | {
-    readonly ZonedDateTime: any;
-    readonly __esModule: boolean;
-    readonly DayOfWeek: any;
-    readonly LocalDateTime: any;
-    readonly Locale: any;
-    readonly DateTimeFormatter: any;
-    readonly Instant: any;
-    readonly LocalDate: any;
-    readonly LocalTime: any;
-    readonly Month: any;
-    readonly OffsetDateTime: any;
-    readonly OffsetTime: any;
-    readonly ZoneId: any;
-    readonly ZoneOffset: any;
-    formatDate: (_a: any) => any;
-};
-export = _exports;
-export const __esModule: boolean;
-export const DayOfWeek: any;
-export const LocalDateTime: any;
-export const ZonedDateTime: any;
-export const Locale: any;
-export const DateTimeFormatter: any;
-export const Instant: any;
-export const LocalDate: any;
-export const LocalTime: any;
-export const Month: any;
-export const OffsetDateTime: any;
-export const OffsetTime: any;
-export const ZoneId: any;
-export const ZoneOffset: any;
-export function formatDate(_a: any): any;
+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 } from "/lib/time/util";
+export { DateTimeFormatter } from "/lib/time/format/date-time-formatter";
+export { Instant } from "/lib/time/instant";
+export { LocalDate } from "/lib/time/local-date";
+export { LocalTime } from "/lib/time/local-time";
+export { Month } from "/lib/time/month";
+export { OffsetDateTime } from "/lib/time/offset-date-time";
+export { OffsetTime } from "/lib/time/offset-time";
+export { ZoneId } from "/lib/time/zone-id";
+export { ZoneOffset } from "/lib/time/zone-offset";
+/**
+ * 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}
+ *
+ * @param date The date as a string
+ * @param pattern The shape of the output string
+ * @param locale The locale of the country you are formatting to
+ */
+export declare function formatDate({ date, pattern, locale }: FormatDateParams): string;
+export declare function formatDate({ date, pattern, locale }: FormatDateParamsAllowNullable): string | undefined;
+export interface FormatDateParams {
+    date: string | Date;
+    pattern: string;
+    locale?: string | undefined;
+}
+export interface FormatDateParamsAllowNullable {
+    date: string | Date | undefined | null;
+    pattern: string;
+    locale?: string | undefined;
+}

package/instant.d.ts

@@ -1,2 +1,33 @@
-export const __esModule: boolean;
-export const Instant: any;
+import type { ZoneOffset, OffsetDateTime, ZoneId, ZonedDateTime } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const Instant: InstantConstructor;
+export interface InstantConstructor {
+    now(): Instant;
+    ofEpochMilli(epochMilli: number): Instant;
+    ofEpochSecond(epochSecond: number): Instant;
+    ofEpochSecond(epochSecond: number, nanoAdjustment: number): Instant;
+    parse(text: string): Instant;
+}
+export interface Instant {
+    atOffset(offset: ZoneOffset): OffsetDateTime;
+    atZone(zone: ZoneId): ZonedDateTime;
+    compareTo(otherInstant: Instant): number;
+    equals(otherInstant: unknown): boolean;
+    toString(): string;
+    getEpochSecond(): number;
+    getNano(): number;
+    isAfter(otherInstant: Instant): boolean;
+    isBefore(otherInstant: Instant): boolean;
+    minusMillis(millisToSubtract: number): Instant;
+    minusNanos(nanosToSubtract: number): Instant;
+    minusSeconds(secondsToSubtract: number): Instant;
+    plusMillis(millisToAdd: number): Instant;
+    plusNanos(nanosToAdd: number): Instant;
+    plusSeconds(secondsToAdd: number): Instant;
+    toEpochMilli(): number;
+}

package/local-date-time.d.ts

@@ -1,2 +1,66 @@
-export const __esModule: boolean;
-export const LocalDateTime: any;
+import type { DateTimeFormatter, Month, LocalDate, LocalTime, ZoneOffset, Instant, ZoneId, DayOfWeek, OffsetDateTime, ZonedDateTime } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const LocalDateTime: LocalDateTimeConstructor;
+export interface LocalDateTimeConstructor {
+    MAX: LocalDateTime;
+    MIN: LocalDateTime;
+    now(): LocalDateTime;
+    now(zone: ZoneId): LocalDateTime;
+    parse(text: string): LocalDateTime;
+    parse(text: string, formatter: DateTimeFormatter): LocalDateTime;
+    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, 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 {
+    atOffset(offset: ZoneOffset): OffsetDateTime;
+    atZone(zone: ZoneId): ZonedDateTime;
+    format(formatter: DateTimeFormatter): string;
+    toString(): string;
+    hashCode(): number;
+    getDayOfMonth(): number;
+    getDayOfWeek(): DayOfWeek;
+    getDayOfYear(): number;
+    getHour(): number;
+    getMinute(): number;
+    getMonth(): Month;
+    getMonthValue(): number;
+    getNano(): number;
+    getSecond(): number;
+    getYear(): number;
+    minusDays(days: number): LocalDateTime;
+    minusHours(hours: number): LocalDateTime;
+    minusMinutes(minutes: number): LocalDateTime;
+    minusMonths(months: number): LocalDateTime;
+    minusNanos(nanos: number): LocalDateTime;
+    minusSeconds(seconds: number): LocalDateTime;
+    minusWeeks(weeks: number): LocalDateTime;
+    minusYears(years: number): LocalDateTime;
+    plusDays(days: number): LocalDateTime;
+    plusHours(hours: number): LocalDateTime;
+    plusMinutes(minutes: number): LocalDateTime;
+    plusMonths(months: number): LocalDateTime;
+    plusNanos(nanos: number): LocalDateTime;
+    plusSeconds(seconds: number): LocalDateTime;
+    plusWeeks(weeks: number): LocalDateTime;
+    plusYears(years: number): LocalDateTime;
+    toLocalDate(): LocalDate;
+    toLocalTime(): LocalTime;
+    withDayOfMonth(dayOfMonth: number): LocalDateTime;
+    withDayOfYear(dayOfYear: number): LocalDateTime;
+    withHour(hour: number): LocalDateTime;
+    withMinute(minute: number): LocalDateTime;
+    withMonth(month: number): LocalDateTime;
+    withNano(nano: number): LocalDateTime;
+    withSecond(second: number): LocalDateTime;
+    withYear(year: number): LocalDateTime;
+}

package/local-date.d.ts

@@ -1,2 +1,58 @@
-export const __esModule: boolean;
-export const LocalDate: any;
+import type { DateTimeFormatter, ZoneId, Month, Instant, LocalDateTime, ZonedDateTime, LocalTime, OffsetTime, OffsetDateTime, DayOfWeek, ZoneOffset } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const LocalDate: LocalDateConstructor;
+interface LocalDateConstructor {
+    EPOCH: LocalDate;
+    MAX: LocalDate;
+    MIN: LocalDate;
+    now(): LocalDate;
+    now(zone: ZoneId): LocalDate;
+    of(year: number, month: number, dayOfMonth: number): LocalDate;
+    of(year: number, month: Month, dayOfMonth: number): LocalDate;
+    ofEpochDay(epochDay: number): LocalDate;
+    ofInstant(instant: Instant, zone: ZoneId): LocalDate;
+    ofYearDay(year: number, dayOfYear: number): LocalDate;
+    parse(text: string): LocalDate;
+    parse(text: string, formatter: DateTimeFormatter): LocalDate;
+}
+export interface LocalDate {
+    atStartOfDay(): LocalDateTime;
+    atStartOfDay(zone: ZoneId): ZonedDateTime;
+    atTime(hour: number, minute: number): LocalDateTime;
+    atTime(hour: number, minute: number, second: number): LocalDateTime;
+    atTime(hour: number, minute: number, second: number, nanoOfSecond: number): LocalDateTime;
+    atTime(time: LocalTime): LocalDateTime;
+    atTime(time: OffsetTime): OffsetDateTime;
+    datesUntil(endExclusive: LocalDate): unknown;
+    format(formatter: DateTimeFormatter): string;
+    getDayOfMonth(): number;
+    getDayOfWeek(): DayOfWeek;
+    getDayOfYear(): number;
+    getMonth(): Month;
+    getMonthValue(): number;
+    getYear(): number;
+    hashCode(): number;
+    toString(): string;
+    isLeapYear(): boolean;
+    lengthOfMonth(): number;
+    lengthOfYear(): number;
+    minusDays(daysToSubtract: number): LocalDate;
+    minusMonths(monthsToSubtract: number): LocalDate;
+    minusWeeks(weeksToSubtract: number): LocalDate;
+    minusYears(yearsToSubtract: number): LocalDate;
+    plusDays(daysToAdd: number): LocalDate;
+    plusMonths(monthsToAdd: number): LocalDate;
+    plusWeeks(weeksToAdd: number): LocalDate;
+    plusYears(yearsToAdd: number): LocalDate;
+    toEpochSecond(time: LocalTime, offset: ZoneOffset): number;
+    withDayOfMonth(dayOfMonth: number): LocalDate;
+    withDayOfYear(dayOfYear: number): LocalDate;
+    withMonth(month: number): LocalDate;
+    withYear(year: number): LocalDate;
+}
+export {};

package/local-time.d.ts

@@ -1,2 +1,53 @@
-export const __esModule: boolean;
-export const LocalTime: any;
+import type { ZoneId, Instant, DateTimeFormatter, LocalDateTime, LocalDate, ZoneOffset, OffsetTime } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const LocalTime: LocalTimeConstructor;
+export interface LocalTimeConstructor {
+    MAX: LocalTime;
+    MIDNIGHT: LocalTime;
+    MIN: LocalTime;
+    NOON: LocalTime;
+    now(): LocalTime;
+    now(zone: ZoneId): LocalTime;
+    of(hour: number, minute: number): LocalTime;
+    of(hour: number, minute: number, second: number): LocalTime;
+    of(hour: number, minute: number, second: number, nanoOfSecond: number): LocalTime;
+    ofInstant(instant: Instant, zone: ZoneId): LocalTime;
+    ofNanoOfDay(nanoOfDay: number): LocalTime;
+    ofSecondOfDay(SecondOfDay: number): LocalTime;
+    parse(text: string): LocalTime;
+    parse(text: string, formatter: DateTimeFormatter): LocalTime;
+}
+export interface LocalTime {
+    atDate(date: LocalDate): LocalDateTime;
+    atOffset(offset: ZoneOffset): OffsetTime;
+    compareTo(other: LocalTime): number;
+    format(formatter: DateTimeFormatter): string;
+    toString(): string;
+    hashCode(): number;
+    getHour(): number;
+    getMinute(): number;
+    getNano(): number;
+    getSecond(): number;
+    isAfter(other: LocalTime): boolean;
+    isBefore(other: LocalTime): boolean;
+    minusHours(hoursToSubtract: number): LocalTime;
+    minusMinutes(minutesToSubtract: number): LocalTime;
+    minusNanos(nanosToSubtract: number): LocalTime;
+    minusSeconds(secondsToSubtract: number): LocalTime;
+    plusHours(hoursToAdd: number): LocalTime;
+    plusMinutes(minutesToAdd: number): LocalTime;
+    plusNanos(nanosToAdd: number): LocalTime;
+    plusSeconds(secondsToAdd: number): LocalTime;
+    toEpochSecond(date: LocalDate, offset: ZoneOffset): number;
+    toNanoOfDay(): number;
+    toSecondOfDay(): number;
+    withHour(hour: number): LocalTime;
+    withMinute(minute: number): LocalTime;
+    withNano(nano: number): LocalTime;
+    withSecond(second: number): LocalTime;
+}

package/month.d.ts

@@ -1,2 +1,23 @@
-export const __esModule: boolean;
-export const Month: any;
+/**
+ * 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}
+ */
+export declare const Month: MonthConstructor;
+export type MonthNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+export interface MonthConstructor {
+    of(month: MonthNumber): Month;
+}
+export interface Month {
+    getValue(): MonthNumber;
+    toString(): string;
+    hashCode(): number;
+    firstDayOfYear(leapYear: boolean): number;
+    firstMonthOfQuarter(): Month;
+    length(leapYear: boolean): number;
+    maxLength(): number;
+    minLength(): number;
+    minus(months: number): Month;
+    plus(months: number): Month;
+}

package/offset-date-time.d.ts

@@ -1,2 +1,75 @@
-export const __esModule: boolean;
-export const OffsetDateTime: any;
+import type { ZoneId, ZoneOffset, LocalDate, LocalTime, LocalDateTime, Instant, DateTimeFormatter, ZonedDateTime, DayOfWeek, Month, OffsetTime } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const OffsetDateTime: OffsetDateTimeConstructor;
+export interface OffsetDateTimeConstructor {
+    MAX: OffsetDateTime;
+    MIN: OffsetDateTime;
+    now(): OffsetDateTime;
+    now(zone: ZoneId): OffsetDateTime;
+    of(year: number, month: number, dayOfMonth: number, hour: number, minute: number, second: number, nanoOfSecond: number, offset: ZoneOffset): OffsetDateTime;
+    of(date: LocalDate, time: LocalTime, offset: ZoneOffset): OffsetDateTime;
+    of(dateTime: LocalDateTime, offset: ZoneOffset): OffsetDateTime;
+    ofInstant(instant: Instant, zone: ZoneId): OffsetDateTime;
+    parse(text: string): OffsetDateTime;
+    parse(text: string, formatter: DateTimeFormatter): OffsetDateTime;
+}
+export interface OffsetDateTime {
+    atZoneSameInstant(zone: ZoneId): ZonedDateTime;
+    atZoneSimilarLocal(zone: ZoneId): ZonedDateTime;
+    compareTo(other: OffsetDateTime): number;
+    toString(): string;
+    format(formatter: DateTimeFormatter): string;
+    getDayOfMonth(): number;
+    getDayOfWeek(): DayOfWeek;
+    getDayOfYear(): number;
+    getHour(): number;
+    getMinute(): number;
+    getMonth(): Month;
+    getMonthValue(): number;
+    getNano(): number;
+    getOffset(): ZoneOffset;
+    getSecond(): number;
+    getYear(): number;
+    hashCode(): number;
+    isAfter(other: OffsetDateTime): boolean;
+    isBefore(other: OffsetDateTime): boolean;
+    isEqual(other: OffsetDateTime): boolean;
+    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;
+    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;
+    toEpochSecond(): number;
+    toInstant(): Instant;
+    toLocalDate(): LocalDate;
+    toLocalDateTime(): LocalDateTime;
+    toLocalTime(): LocalTime;
+    toOffsetTime(): OffsetTime;
+    toZonedDateTime(): ZonedDateTime;
+    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;
+}

package/offset-time.d.ts

@@ -1,2 +1,50 @@
-export const __esModule: boolean;
-export const OffsetTime: any;
+import type { ZoneId, ZoneOffset, LocalDate, LocalTime, Instant, DateTimeFormatter, OffsetDateTime } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const OffsetTime: OffsetTimeConstructor;
+export interface OffsetTimeConstructor {
+    MAX: OffsetTime;
+    MIN: OffsetTime;
+    now(): OffsetTime;
+    now(zone: ZoneId): OffsetTime;
+    of(hour: number, minute: number, second: number, nanoOfSecond: number, offset: ZoneOffset): OffsetTime;
+    of(time: LocalTime, offset: ZoneOffset): OffsetTime;
+    ofInstant(instant: Instant, zone: ZoneId): OffsetTime;
+    parse(text: string): OffsetTime;
+    parse(text: string, formatter: DateTimeFormatter): OffsetTime;
+}
+export interface OffsetTime {
+    atDate(date: LocalDate): OffsetDateTime;
+    compareTo(other: OffsetTime): number;
+    format(formatter: DateTimeFormatter): string;
+    getHour(): number;
+    getMinute(): number;
+    getNano(): number;
+    getOffset(): ZoneOffset;
+    getSecond(): number;
+    hashCode(): number;
+    toString(): string;
+    isAfter(other: OffsetTime): boolean;
+    isBefore(other: OffsetTime): boolean;
+    isEqual(other: OffsetTime): boolean;
+    minusHours(hours: number): OffsetTime;
+    minusMinutes(minutes: number): OffsetTime;
+    minusNanos(nanos: number): OffsetTime;
+    minusSeconds(seconds: number): OffsetTime;
+    plusHours(hours: number): OffsetTime;
+    plusMinutes(minutes: number): OffsetTime;
+    plusNanos(nanos: number): OffsetTime;
+    plusSeconds(seconds: number): OffsetTime;
+    toEpochSecond(date: LocalDate): number;
+    toLocalTime(): LocalTime;
+    withHour(hour: number): OffsetTime;
+    withMinute(minute: number): OffsetTime;
+    withNano(nanoOfSecond: number): OffsetTime;
+    withOffsetSameInstant(offset: ZoneOffset): OffsetTime;
+    withOffsetSameLocal(offset: ZoneOffset): OffsetTime;
+    withSecond(second: number): OffsetTime;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@item-enonic-types/lib-time",
-  "version": "0.1.1",
+  "version": "1.0.0",
   "description": "Type definitions for lib-time",
   "license": "MIT",
   "files": [
@@ -14,33 +14,33 @@
     "dist:server": "cross-env NODE_ENV=production webpack --config webpack.server.config.js --color",
     "dist": "run-p -c dist:*",
     "lint": "eslint --fix 'src/**/*.ts'",
-    "prepublishOnly": "tsc --declarationDir build/types --emitDeclarationOnly true --declaration true && cp -r ./build/types/build/resources/main/lib/time/* .",
+    "prepublishOnly": "tsc --declarationDir build/types --emitDeclarationOnly true --declaration true && cp -r ./build/types/* .",
     "postpublish": "rm ./*.d.ts && rm -r ./format"
   },
   "devDependencies": {
-    "@babel/core": "^7.19.6",
+    "@babel/core": "^7.21.0",
     "@babel/plugin-proposal-class-properties": "^7.18.6",
-    "@babel/preset-env": "^7.19.4",
-    "@babel/register": "^7.18.9",
-    "@typescript-eslint/eslint-plugin": "^5.41.0",
-    "@typescript-eslint/parser": "^5.41.0",
-    "babel-loader": "^8.2.5",
-    "browserslist": "^4.21.4",
+    "@babel/preset-env": "^7.20.2",
+    "@babel/register": "^7.21.0",
+    "@item-enonic-types/lib-testing": "^7.11.3",
+    "@types/node": "^18.14.1",
+    "@typescript-eslint/eslint-plugin": "^5.53.0",
+    "@typescript-eslint/parser": "^5.53.0",
+    "babel-loader": "^9.1.2",
+    "browserslist": "^4.21.5",
     "browserslist-config-enonic": "^1.0.7",
     "cross-env": "^7.0.3",
-    "eslint": "^8.26.0",
-    "eslint-config-prettier": "^8.5.0",
+    "eslint": "^8.34.0",
+    "eslint-config-prettier": "^8.6.0",
     "eslint-plugin-prettier": "^4.2.1",
-    "glob": "^8.0.3",
+    "glob": "^8.1.0",
     "npm-run-all": "^4.1.5",
-    "prettier": "^2.7.1",
+    "prettier": "^2.8.4",
     "ramda": "^0.28.0",
-    "ts-loader": "^9.4.1",
-    "typescript": "^4.8.4",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^4.10.0",
-    "@item-enonic-types/lib-testing": "^7.11.3",
-    "enonic-types": "^7.11.3"
+    "ts-loader": "^9.4.2",
+    "typescript": "^4.9.5",
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1"
   },
   "browserslist": [
     "extends browserslist-config-enonic"

package/tsconfig.json

@@ -3,7 +3,7 @@
     "module": "commonjs",
     "moduleResolution": "node",
     "target": "es5",
-    "sourceMap": true,
+    "sourceMap": false,
     "allowJs": true,
     "noImplicitAny": true,
     "noImplicitReturns": true,
@@ -17,6 +17,9 @@
     "declaration": true,
     "declarationDir": "build/types"
   },
+  "exclude": [
+    "./build/*",
+  ],
   "types": [
     "types"
   ]

package/util.d.ts

@@ -1,2 +1,65 @@
-export const __esModule: boolean;
-export const Locale: any;
+/**
+ * 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}
+ */
+export declare const Locale: LocaleConstructor;
+export interface LocaleConstructor {
+    new (language: string): Locale;
+    new (language: string, country: string): Locale;
+    new (language: string, country: string, variant: string): Locale;
+    CANADA: Locale;
+    CANADA_FRENCH: Locale;
+    CHINA: Locale;
+    CHINESE: Locale;
+    ENGLISH: Locale;
+    FRANCE: Locale;
+    GERMAN: Locale;
+    GERMANY: Locale;
+    ITALIAN: Locale;
+    ITALY: Locale;
+    JAPAN: Locale;
+    KOREA: Locale;
+    KOREAN: Locale;
+    PRC: Locale;
+    PRIVATE_USE_EXTENSION: Locale;
+    ROOT: Locale;
+    SIMPLIFIED_CHINESE: Locale;
+    TAIWAN: Locale;
+    TRADITIONAL_CHINESE: Locale;
+    UK: Locale;
+    UNICODE_LOCALE_EXTENSION: Locale;
+    US: Locale;
+    forLanguageTag(languageTag: string): Locale;
+    getAvailableLocales(): Locale[];
+    getDefault(): Locale;
+    getISOCountries(): string[];
+    getISOLanguages(): string[];
+    setDefault(newLocale: Locale): void;
+}
+export interface Locale {
+    getSubLocale(): string;
+    getCountry(): string;
+    getDisplayCountry(): string;
+    getDisplayLanguage(): string;
+    getDisplayName(): string;
+    getDisplayName(inLocale: Locale): string;
+    getDisplayScript(): string;
+    getDisplayScript(inLocale: Locale): string;
+    getDisplayVariant(): string;
+    getDisplayVariant(inLocale: Locale): string;
+    getExtension(key: string): string;
+    getExtensionKeys(): unknown;
+    getISO3Country(): string;
+    getISO3Language(): string;
+    getLanguage(): string;
+    getScript(): string;
+    getUnicodeLocaleAttributes(): unknown;
+    getUnicodeLocaleKeys(): unknown;
+    getUnicodeLocaleType(key: string): string;
+    getVariant(): string;
+    hasExtensions(): boolean;
+    stripExtensions(): Locale;
+    toLanguageTag(): string;
+    toString(): string;
+    hashCode(): number;
+}

package/webpack.server.config.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/zone-id.d.ts

@@ -1,2 +1,19 @@
-export const __esModule: boolean;
-export const ZoneId: any;
+import type { ZoneOffset } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const ZoneId: ZoneIdConstructor;
+export interface ZoneIdConstructor {
+    SHORT_IDS: Record<string, string>;
+    getAvailableZoneIds(): ReadonlyArray<string>;
+    of(zoneId: string): ZoneId;
+    of(zoneId: string, aliasMap: Record<string, string>): ZoneId;
+    ofOffset(prefix: string, offset: ZoneOffset): ZoneId;
+    systemDefault(): ZoneId;
+}
+export interface ZoneId {
+    getId(): string;
+    normalized(): ZoneId;
+    toString(): string;
+}

package/zone-offset.d.ts

@@ -1,2 +1,23 @@
-export const __esModule: boolean;
-export const ZoneOffset: any;
+/**
+ * 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}
+ */
+export declare const ZoneOffset: ZoneOffsetConstructor;
+export interface ZoneOffsetConstructor {
+    MAX: ZoneOffset;
+    MIN: ZoneOffset;
+    UTC: ZoneOffset;
+    of(offsetId: string): ZoneOffset;
+    ofHours(hours: number): ZoneOffset;
+    ofHoursMinutesSeconds(hours: number, minutes: number, seconds: number): ZoneOffset;
+    ofTotalSeconds(totalSeconds: number): ZoneOffset;
+}
+export interface ZoneOffset {
+    compareTo(other: ZoneOffset): number;
+    getId(): string;
+    getTotalSeconds(): number;
+    hashCode(): number;
+    toString(): string;
+}

package/zoned-date-time.d.ts

@@ -1,2 +1,69 @@
-export const __esModule: boolean;
-export const ZonedDateTime: any;
+import type { DateTimeFormatter, ZoneId, ZoneOffset, LocalDate, LocalTime, LocalDateTime, Instant, OffsetDateTime, DayOfWeek, Month } from "/lib/time";
+/**
+ * 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}
+ */
+export declare const ZonedDateTime: ZonedDateTimeConstructor;
+export interface ZonedDateTimeConstructor {
+    now(): ZonedDateTime;
+    now(zone: ZoneId): ZonedDateTime;
+    of(year: number, month: number, dayOfMonth: number, hour: number, minute: number, second: number, nanoOfSecond: number, zone: ZoneId): ZonedDateTime;
+    of(date: LocalDate, time: LocalTime, zone: ZoneId): ZonedDateTime;
+    of(localDateTime: LocalDateTime, zone: ZoneId): ZonedDateTime;
+    ofInstant(instant: Instant, zone: ZoneId): ZonedDateTime;
+    ofInstant(localDateTime: LocalDateTime, offset: ZoneOffset, zone: ZoneId): ZonedDateTime;
+    ofLocal(localDateTime: LocalDateTime, zone: ZoneId, preferredOffset: ZoneOffset): ZonedDateTime;
+    ofStrict(localDateTime: LocalDateTime, offset: ZoneOffset, zone: ZoneId): ZonedDateTime;
+    parse(text: string): ZonedDateTime;
+    parse(text: string, formatter: DateTimeFormatter): ZonedDateTime;
+}
+export interface ZonedDateTime {
+    format(formatter: DateTimeFormatter): string;
+    getDayOfMonth(): number;
+    getDayOfWeek(): DayOfWeek;
+    getDayOfYear(): number;
+    getHour(): number;
+    getMinute(): number;
+    getMonth(): Month;
+    getMonthValue(): number;
+    getNano(): number;
+    getOffset(): ZoneOffset;
+    getSecond(): number;
+    getYear(): number;
+    getZone(): ZoneId;
+    hashCode(): number;
+    minusDays(days: number): ZonedDateTime;
+    minusHours(hours: number): ZonedDateTime;
+    minusMinutes(minutes: number): ZonedDateTime;
+    minusMonths(months: number): ZonedDateTime;
+    minusNanos(nanos: number): ZonedDateTime;
+    minusSeconds(seconds: number): ZonedDateTime;
+    minusWeeks(weeks: number): ZonedDateTime;
+    minusYears(years: number): ZonedDateTime;
+    plusDays(days: number): ZonedDateTime;
+    plusHours(hours: number): ZonedDateTime;
+    plusMinutes(minutes: number): ZonedDateTime;
+    plusMonths(months: number): ZonedDateTime;
+    plusNanos(nanos: number): ZonedDateTime;
+    plusSeconds(seconds: number): ZonedDateTime;
+    plusWeeks(weeks: number): ZonedDateTime;
+    plusYears(years: number): ZonedDateTime;
+    toLocalDate(): LocalDate;
+    toLocalDateTime(): LocalDateTime;
+    toLocalTime(): LocalTime;
+    toOffsetDateTime(): OffsetDateTime;
+    withDayOfMonth(dayOfMonth: number): ZonedDateTime;
+    withDayOfYear(dayOfYear: number): ZonedDateTime;
+    withEarlierOffsetAtOverlap(): ZonedDateTime;
+    withFixedOffsetZone(): ZonedDateTime;
+    withHour(hour: number): ZonedDateTime;
+    withLaterOffsetAtOverlap(): ZonedDateTime;
+    withMinute(minute: number): ZonedDateTime;
+    withMonth(month: number): ZonedDateTime;
+    withNano(nanoOfSecond: number): ZonedDateTime;
+    withSecond(second: number): ZonedDateTime;
+    withYear(year: number): ZonedDateTime;
+    withZoneSameInstant(zone: ZoneId): ZonedDateTime;
+    withZoneSameLocal(zone: ZoneId): ZonedDateTime;
+    toString(): string;
+}