@rvoh/dream 2.3.0-alpha.6 → 2.3.0-alpha.8

package/dist/types/src/utils/datetime/CalendarDate.d.ts

@@ -1,5 +1,5 @@
-import { CalendarDateDurationLike, CalendarDateDurationUnit, CalendarDateUnit } from '../../types/calendardate.js';
-import { type DateTimeJSOptions, type DateTimeObject, type LocaleOptions, type WeekdayName, type Zone } from '../../types/datetime.js';
+import { CalendarDateDiffResult, CalendarDateDurationLike, CalendarDateDurationUnit, CalendarDateUnit, type CalendarDateObject } from '../../types/calendardate.js';
+import { type DateTimeJSOptions, type DateTimeOptions, type LocaleOptions, type WeekdayName, type Zone } from '../../types/datetime.js';
 import { DateTime } from './DateTime.js';
 /**
  * CalendarDate represents a date without time or timezone information.
@@ -7,18 +7,9 @@ import { DateTime } from './DateTime.js';
 export default class CalendarDate {
     protected readonly dateTime: DateTime;
     /**
-     * Creates a CalendarDate from a DateTime, year/month/day, or defaults to today in UTC.
-     * @param source - DateTime instance, year number, or null/undefined for today
-     * @param month - Month (1-12) when source is a year number
-     * @param day - Day of month when source is a year number
-     * @example
-     * ```ts
-     * new CalendarDate()                          // today
-     * new CalendarDate(DateTime.now())            // from DateTime
-     * new CalendarDate(2026, 2, 7)               // February 7, 2026
-     * ```
+     * @internal
      */
-    constructor(source?: DateTime | number | null, month?: number, day?: number);
+    constructor(source?: DateTime | CalendarDateObject | null);
     /**
      * Create a CalendarDate from a DateTime instance.
      * @param dateTime - A DateTime instance
@@ -40,7 +31,7 @@ export default class CalendarDate {
      * CalendarDate.fromJSDate(new Date(), { zone: 'America/New_York' })
      * ```
      */
-    static fromJSDate(javascriptDate: Date, { zone }?: {
+    static fromJSDate(javascriptDate: Date, opts?: {
         zone?: string | Zone;
     }): CalendarDate;
     /**
@@ -52,10 +43,9 @@ export default class CalendarDate {
      * @example
      * ```ts
      * CalendarDate.fromISO('2026-02-07')
-     * CalendarDate.fromISO('2026-02-07T09:00:00Z')  // time portion ignored
      * ```
      */
-    static fromISO(str: string, { zone }?: {
+    static fromISO(str: string, opts?: {
         zone?: string | Zone;
     }): CalendarDate;
     /**
@@ -84,10 +74,7 @@ export default class CalendarDate {
      * CalendarDate.fromFormat('mai 25, 1982', 'MMMM dd, yyyy', { locale: 'fr' })
      * ```
      */
-    static fromFormat(text: string, format: string, { zone, locale }?: {
-        zone?: string | Zone;
-        locale?: string;
-    }): CalendarDate;
+    static fromFormat(text: string, format: string, opts?: DateTimeOptions): CalendarDate;
     /**
      * Create a CalendarDate from an object with date units.
      * @param obj - Object with year, month, day properties
@@ -99,7 +86,7 @@ export default class CalendarDate {
      * CalendarDate.fromObject({ year: 2026, month: 2, day: 7 })
      * ```
      */
-    static fromObject(obj: DateTimeObject, opts?: DateTimeJSOptions): CalendarDate;
+    static fromObject(obj: CalendarDateObject, opts?: DateTimeJSOptions): CalendarDate;
     /**
      * Returns a CalendarDate for today's date.
      * @param options - Optional zone (defaults to UTC)
@@ -110,7 +97,7 @@ export default class CalendarDate {
      * CalendarDate.today({ zone: 'America/New_York' })
      * ```
      */
-    static today({ zone }?: {
+    static today(opts?: {
         zone?: string | Zone;
     }): CalendarDate;
     /**
@@ -148,6 +135,17 @@ export default class CalendarDate {
      * ```
      */
     toISO(): string;
+    /**
+     * Returns the date as an ISO date string.
+     * Alias for `toISO()`.
+     *
+     * @returns ISO date string (e.g., '2026-02-07')
+     * @example
+     * ```ts
+     * CalendarDate.fromObject({ year: 2026, month: 2, day: 7 }).toISODate()  // '2026-02-07'
+     * ```
+     */
+    toISODate(): string;
     /**
      * Returns the date as an SQL date string.
      * @returns SQL date string (e.g., '2026-02-07')
@@ -156,6 +154,7 @@ export default class CalendarDate {
      * CalendarDate.fromObject({ year: 2026, month: 2, day: 7 }).toSQL()  // '2026-02-07'
      * ```
      */
+    private _toSQL;
     toSQL(): string;
     /**
      * Returns the date as an ISO string for JSON serialization.
@@ -167,23 +166,15 @@ export default class CalendarDate {
      */
     toJSON(): string;
     /**
-     * Returns the epoch milliseconds for the date at midnight UTC.
-     * @returns Unix timestamp in milliseconds
-     * @example
-     * ```ts
-     * CalendarDate.fromISO('2026-02-07').valueOf()
-     * ```
-     */
-    valueOf(): number;
-    /**
-     * Returns the date as an ISO date string (same as toISO).
+     * Returns the date as an ISO date string (for valueOf() operations).
      * @returns ISO date string (e.g., '2026-02-07')
      * @example
      * ```ts
-     * CalendarDate.fromObject({ year: 2026, month: 2, day: 7 }).toISODate()  // '2026-02-07'
+     * CalendarDate.fromISO('2026-02-07').valueOf()
      * ```
      */
-    toISODate(): string;
+    private _valueOf;
+    valueOf(): string;
     /**
      * Returns a localized string representation of the date.
      * @param formatOpts - Intl.DateTimeFormat options for formatting
@@ -305,15 +296,16 @@ export default class CalendarDate {
      */
     minus(duration: CalendarDateDurationLike): CalendarDate;
     /**
-     * Returns the latest CalendarDate from the given arguments.
-     * @param calendarDates - CalendarDates to compare
-     * @returns The latest CalendarDate
+     * Returns a new CalendarDate with the given date units set.
+     * @param values - Object with date units to set (year, month, day)
+     * @returns A new CalendarDate
+     * @throws {InvalidCalendarDate} When the underlying DateTime operation fails
      * @example
      * ```ts
-     * CalendarDate.max(date1, date2, date3)
+     * CalendarDate.fromISO('2026-02-07').set({ year: 2025, day: 15 })  // 2025-02-15
      * ```
      */
-    static max(...calendarDates: Array<CalendarDate>): CalendarDate;
+    set(values: Partial<CalendarDateObject>): CalendarDate;
     /**
      * Returns the earliest CalendarDate from the given arguments.
      * @param calendarDates - CalendarDates to compare
@@ -323,7 +315,17 @@ export default class CalendarDate {
      * CalendarDate.min(date1, date2, date3)
      * ```
      */
-    static min(...calendarDates: Array<CalendarDate>): CalendarDate;
+    static min(...calendarDates: CalendarDate[]): CalendarDate | null;
+    /**
+     * Returns the latest CalendarDate from the given arguments.
+     * @param calendarDates - CalendarDates to compare
+     * @returns The latest CalendarDate
+     * @example
+     * ```ts
+     * CalendarDate.max(date1, date2, date3)
+     * ```
+     */
+    static max(...calendarDates: CalendarDate[]): CalendarDate | null;
     /**
      * Returns true if this and other are in the same unit of time.
      * @param otherCalendarDate - CalendarDate to compare against
@@ -348,21 +350,37 @@ export default class CalendarDate {
      * const d1 = CalendarDate.fromISO('2026-02-07')
      * const d2 = CalendarDate.fromISO('2026-02-15')
      * d2.diff(d1, 'days')    // 8
-     * d2.diff(d1, 'months')  // 0
      * ```
      */
-    diff(otherCalendarDate: CalendarDate, duration: CalendarDateDurationUnit): number;
     /**
-     * Returns the difference between this CalendarDate and today in the specified unit.
-     * @param duration - Unit for the difference ('years', 'quarters', 'months', 'weeks', or 'days')
-     * @returns Numeric difference in the specified unit (rounded up)
+     * Returns the difference between this CalendarDate and another in the specified unit(s).
+     *
+     * @param other - CalendarDate to compare against
+     * @param unit - Unit or units to return (years, quarters, months, weeks, days)
+     * @returns Object with only the specified units (or all units if not specified)
+     * @example
+     * ```ts
+     * const d1 = CalendarDate.fromISO('2026-02-15')
+     * const d2 = CalendarDate.fromISO('2026-02-07')
+     * d1.diff(d2, 'days')  // { days: 8 }
+     * d1.diff(d2, ['months', 'days'])  // { months: 0, days: 8 }
+     * d1.diff(d2)  // { years: 0, months: 0, days: 8 }
+     * ```
+     */
+    diff<U extends CalendarDateDurationUnit | CalendarDateDurationUnit[] | undefined = undefined>(other: CalendarDate, unit?: U): CalendarDateDiffResult<U>;
+    /**
+     * Returns the difference between this CalendarDate and today in the specified unit(s).
+     *
+     * @param unit - Unit or units to return (years, quarters, months, weeks, days)
+     * @returns Object with only the specified units (or all units if not specified)
      * @example
      * ```ts
      * const future = CalendarDate.today().plus({ days: 5 })
-     * future.diffNow('days')  // approximately 5
+     * future.diffNow('days')  // { days: 5 }
+     * future.diffNow(['months', 'days'])  // { months: 0, days: 5 }
      * ```
      */
-    diffNow(duration: CalendarDateDurationUnit): number;
+    diffNow<U extends CalendarDateDurationUnit | CalendarDateDurationUnit[] | undefined = undefined>(unit?: U): CalendarDateDiffResult<U>;
     /**
      * Returns true if this CalendarDate equals another CalendarDate.
      * @param otherCalendarDate - CalendarDate to compare

package/dist/types/src/utils/datetime/ClockTime.d.ts

@@ -0,0 +1,138 @@
+import { type ClockTimeObject } from '../../types/clocktime.js';
+import { type LocaleOptions } from '../../types/datetime.js';
+import BaseClockTime from './BaseClockTime.js';
+/**
+ * ClockTime represents a time of day without timezone information.
+ *
+ * Useful for representing TIME WITHOUT TIME ZONE fields from a Postgres database.
+ * All output methods strip timezone offset information.
+ */
+export default class ClockTime extends BaseClockTime {
+    /**
+     * Create a ClockTime from a JavaScript Date.
+     * @param javascriptDate - A JavaScript Date instance
+     * @returns A ClockTime for the time portion
+     * @example
+     * ```ts
+     * ClockTime.fromJSDate(new Date())
+     * ```
+     */
+    static fromJSDate(javascriptDate: Date): ClockTime;
+    /**
+     * Create a ClockTime from an ISO 8601 time string.
+     * Preserves the time values as-is, regardless of any timezone info in the string.
+     * @param str - ISO time string (e.g., '14:30:45.123456')
+     * @returns A ClockTime for the given time
+     * @throws {InvalidClockTime} When the ISO string is invalid
+     * @example
+     * ```ts
+     * ClockTime.fromISO('14:30:45.123456')      // stores 14:30:45.123456
+     * ClockTime.fromISO('14:30:45.123456-05:00') // stores 14:30:45.123456 (timezone ignored)
+     * ```
+     */
+    static fromISO(str: string): ClockTime;
+    /**
+     * Create a ClockTime from an SQL time string.
+     * Preserves the time values as-is, regardless of any timezone info in the string.
+     * @param str - SQL time string (e.g., '14:30:45.123456')
+     * @returns A ClockTime for the given time
+     * @throws {InvalidClockTime} When the SQL string is invalid
+     * @example
+     * ```ts
+     * ClockTime.fromSQL('14:30:45.123456')       // stores 14:30:45.123456
+     * ClockTime.fromSQL('14:30:45.123456+05:30') // stores 14:30:45.123456 (timezone ignored)
+     * ```
+     */
+    static fromSQL(str: string): ClockTime;
+    /**
+     * Create a ClockTime from a custom format string.
+     * Uses Luxon format tokens (e.g., 'HH:mm:ss', 'hh:mm a').
+     * @param text - The string to parse
+     * @param format - Format string using Luxon tokens
+     * @param opts - Optional configuration
+     * @param opts.locale - Locale for parsing (e.g., 'en-US', 'fr-FR')
+     * @param opts.numberingSystem - Numbering system (e.g., 'arab', 'beng')
+     * @param opts.outputCalendar - Output calendar system (e.g., 'islamic', 'hebrew')
+     * @returns A ClockTime for the parsed time
+     * @throws {InvalidClockTime} When the string doesn't match the format or is invalid
+     * @example
+     * ```ts
+     * ClockTime.fromFormat('14:30:45', 'HH:mm:ss')
+     * ClockTime.fromFormat('2:30 PM', 'h:mm a')
+     * ```
+     */
+    static fromFormat(text: string, format: string, opts?: LocaleOptions): ClockTime;
+    /**
+     * Create a ClockTime from an object with time units.
+     * @param obj - Object with hour, minute, second, millisecond, microsecond properties
+     * @param opts - Optional configuration
+     * @param opts.locale - Locale (e.g., 'en-US', 'fr-FR')
+     * @param opts.numberingSystem - Numbering system (e.g., 'arab', 'beng')
+     * @param opts.outputCalendar - Output calendar system (e.g., 'islamic', 'hebrew')
+     * @returns A ClockTime for the given components
+     * @throws {InvalidClockTime} When time values are invalid
+     * @example
+     * ```ts
+     * ClockTime.fromObject({ hour: 14, minute: 30, second: 45 })
+     * ClockTime.fromObject({ hour: 14, minute: 30 })
+     * ```
+     */
+    static fromObject(obj: Partial<ClockTimeObject>, opts?: LocaleOptions): ClockTime;
+    /**
+     * Returns a ClockTime for the current time.
+     * @returns A ClockTime for now
+     * @example
+     * ```ts
+     * ClockTime.now()
+     * ```
+     */
+    static now(): ClockTime;
+    /**
+     * Returns the time as an ISO 8601 time string without timezone offset.
+     * Alias for `toISOTime()`.
+     *
+     * @param opts - Optional format options
+     * @param opts.suppressMilliseconds - If true, omits milliseconds/microseconds when they are zero
+     * @param opts.suppressSeconds - If true, omits seconds when they are zero
+     * @param opts.format - Format variant: 'basic' (compact) or 'extended' (default, with colons)
+     * @returns ISO time string without timezone offset (e.g., '14:30:45.123456')
+     * @example
+     * ```ts
+     * ClockTime.fromObject({ hour: 14, minute: 30, second: 45 }).toISO()  // '14:30:45.000000'
+     * ClockTime.fromISO('14:30:45-05:00').toISO()  // '14:30:45.000000' (timezone stripped)
+     * ```
+     */
+    toISO(opts?: {
+        suppressMilliseconds?: boolean;
+        suppressSeconds?: boolean;
+        format?: 'basic' | 'extended';
+    }): string;
+    /**
+     * Returns the SQL time string without timezone offset.
+     * Result is memoized for performance.
+     *
+     * @returns SQL time string without timezone offset (e.g., '14:30:45.123456')
+     * @example
+     * ```ts
+     * ClockTime.fromISO('14:30:45').toSQL()  // '14:30:45.000000'
+     * ```
+     */
+    toSQL(): string;
+    protected static wrapLuxonError<T>(fn: () => T): T;
+    protected wrapLuxonError<T>(fn: () => T): T;
+}
+/**
+ * Thrown when a ClockTime is invalid (e.g., invalid input or time values).
+ * @param error - The original error (available as cause)
+ * @example
+ * ```ts
+ * try {
+ *   ClockTime.fromISO('25:00:00')
+ * } catch (e) {
+ *   if (e instanceof InvalidClockTime) console.error(e.message)
+ * }
+ * ```
+ */
+export declare class InvalidClockTime extends Error {
+    constructor(error: Error);
+}

package/dist/types/src/utils/datetime/ClockTimeTz.d.ts

@@ -0,0 +1,194 @@
+import { type ClockTimeObject } from '../../types/clocktime.js';
+import { type DateTimeJSOptions, type DateTimeOptions, type Zone } from '../../types/datetime.js';
+import BaseClockTime from './BaseClockTime.js';
+/**
+ * ClockTimeTz represents a time of day with timezone information.
+ *
+ * Useful for representing TIME WITH TIME ZONE fields from a Postgres database.
+ * All output methods include timezone offset information.
+ */
+export default class ClockTimeTz extends BaseClockTime {
+    /**
+     * Create a ClockTimeTz from a JavaScript Date.
+     * @param javascriptDate - A JavaScript Date instance
+     * @param options - Optional configuration
+     * @param options.zone - Timezone to interpret the date in (IANA timezone name or Zone object)
+     * @returns A ClockTimeTz for the time portion
+     * @example
+     * ```ts
+     * ClockTimeTz.fromJSDate(new Date())
+     * ClockTimeTz.fromJSDate(new Date(), { zone: 'America/New_York' })
+     * ```
+     */
+    static fromJSDate(javascriptDate: Date, opts?: {
+        zone?: string | Zone;
+    }): ClockTimeTz;
+    /**
+     * Create a ClockTimeTz from an ISO 8601 time string.
+     * If the string includes timezone information, it will be used.
+     * If no timezone is in the string, it will be interpreted as UTC.
+     * @param str - ISO time string (e.g., '14:30:45.123456-05:00')
+     * @param options - Optional configuration
+     * @param options.zone - Timezone to interpret the time in (overrides timezone in string)
+     * @returns A ClockTimeTz for the given time
+     * @throws {InvalidClockTimeTz} When the ISO string is invalid
+     * @example
+     * ```ts
+     * ClockTimeTz.fromISO('14:30:45.123456')        // Interpreted as UTC
+     * ClockTimeTz.fromISO('14:30:45.123456-05:00')  // Uses timezone from string
+     * ```
+     */
+    static fromISO(str: string, opts?: {
+        zone?: string | Zone;
+    }): ClockTimeTz;
+    /**
+     * Create a ClockTimeTz from an SQL time string.
+     * If no zone option is provided, the time will be interpreted as UTC.
+     * @param str - SQL time string (e.g., '14:30:45.123456')
+     * @param options - Optional configuration
+     * @param options.zone - Timezone to interpret the time in (overrides timezone in string)
+     * @returns A ClockTimeTz for the given time
+     * @throws {InvalidClockTimeTz} When the SQL string is invalid
+     * @example
+     * ```ts
+     * ClockTimeTz.fromSQL('14:30:45.123456')                    // Interpreted as UTC
+     * ClockTimeTz.fromSQL('14:30:45.123456+05:30')              // Uses timezone from string
+     * ClockTimeTz.fromSQL('14:30:45', { zone: 'America/Chicago' })  // Uses specified zone
+     * ```
+     */
+    static fromSQL(str: string, opts?: {
+        zone?: string | Zone;
+    }): ClockTimeTz;
+    /**
+     * Create a ClockTimeTz from a custom format string.
+     * Uses Luxon format tokens (e.g., 'HH:mm:ss', 'hh:mm a').
+     * @param text - The string to parse
+     * @param format - Format string using Luxon tokens
+     * @param opts - Optional configuration
+     * @param opts.zone - Timezone to interpret the time in (IANA timezone name or Zone object)
+     * @param opts.locale - Locale for parsing (e.g., 'en-US', 'fr-FR')
+     * @param opts.numberingSystem - Numbering system (e.g., 'arab', 'beng')
+     * @param opts.outputCalendar - Output calendar system (e.g., 'islamic', 'hebrew')
+     * @returns A ClockTimeTz for the parsed time
+     * @throws {InvalidClockTimeTz} When the string doesn't match the format or is invalid
+     * @example
+     * ```ts
+     * ClockTimeTz.fromFormat('14:30:45', 'HH:mm:ss')
+     * ClockTimeTz.fromFormat('2:30 PM', 'h:mm a')
+     * ClockTimeTz.fromFormat('14:30:45 -05:00', 'HH:mm:ss ZZ')
+     * ```
+     */
+    static fromFormat(text: string, format: string, opts?: DateTimeOptions): ClockTimeTz;
+    /**
+     * Create a ClockTimeTz from an object with time units.
+     * @param obj - Object with hour, minute, second, millisecond, microsecond properties
+     * @param opts - Optional configuration
+     * @param opts.zone - Timezone for the time (IANA timezone name or Zone object, defaults to UTC)
+     * @param opts.locale - Locale (e.g., 'en-US', 'fr-FR')
+     * @param opts.numberingSystem - Numbering system (e.g., 'arab', 'beng')
+     * @param opts.outputCalendar - Output calendar system (e.g., 'islamic', 'hebrew')
+     * @returns A ClockTimeTz for the given components
+     * @throws {InvalidClockTimeTz} When time values are invalid
+     * @example
+     * ```ts
+     * ClockTimeTz.fromObject({ hour: 14, minute: 30, second: 45 })  // UTC by default
+     *
+     * // Note for when sending a named, non-UTC time zone, soch as 'America/New_York':
+     * // Sending a non-UTC time zone will interpret the time zone based on DateTime.now,
+     * // meaning the resulting ClockTimeTz will have a different time and offset when
+     * // generated during daylight savings time than not during daylight savings time
+     * ClockTimeTz.fromObject({ hour: 14, minute: 30 }, { zone: 'America/New_York' })
+     * ```
+     */
+    static fromObject(obj: Partial<ClockTimeObject>, opts?: DateTimeJSOptions): ClockTimeTz;
+    /**
+     * Returns the time as an ISO 8601 time string with timezone offset.
+     * Alias for `toISOTime()`.
+     *
+     * @param opts - Optional format options
+     * @param opts.suppressMilliseconds - If true, omits milliseconds/microseconds when they are zero
+     * @param opts.suppressSeconds - If true, omits seconds when they are zero
+     * @param opts.format - Format variant: 'basic' (compact) or 'extended' (default, with colons)
+     * @returns ISO time string with timezone offset (e.g., '14:30:45.123456-05:00')
+     * @example
+     * ```ts
+     * ClockTimeTz.fromObject({ hour: 14, minute: 30, second: 45 }).toISO()  // '14:30:45.000000+00:00'
+     * ClockTimeTz.fromISO('14:30:45-05:00').toISO()  // '14:30:45.000000-05:00'
+     * ```
+     */
+    toISO(opts?: {
+        suppressMilliseconds?: boolean;
+        suppressSeconds?: boolean;
+        format?: 'basic' | 'extended';
+    }): string;
+    /**
+     * Returns the SQL time string with timezone offset.
+     * Result is memoized for performance.
+     *
+     * @returns SQL time string with timezone offset (e.g., '14:30:45.123456 -05:00')
+     * @example
+     * ```ts
+     * ClockTimeTz.fromISO('14:30:45-05:00').toSQL()  // '14:30:45.000000 -05:00'
+     * ```
+     */
+    toSQL(): string;
+    /**
+     * Gets the timezone name.
+     * @returns The timezone name
+     * @example
+     * ```ts
+     * ClockTimeTz.fromObject({ hour: 14 }, { zone: 'America/New_York' }).zoneName
+     * ```
+     */
+    get zoneName(): string;
+    /**
+     * Gets the timezone offset in minutes.
+     * @returns The offset in minutes
+     * @example
+     * ```ts
+     * ClockTimeTz.fromISO('14:30:45-05:00').offset  // -300
+     * ```
+     */
+    get offset(): number;
+    /**
+     * Returns a ClockTime for the current time.
+     * @returns A ClockTime for now
+     * @example
+     * ```ts
+     * ClockTime.now()
+     * ```
+     */
+    static now(opts?: {
+        zone?: string | Zone;
+    }): ClockTimeTz;
+    /**
+     * Returns a new ClockTimeTz with the timezone changed.
+     * The time value changes to reflect the same instant in the new timezone.
+     * @param zone - The timezone to convert to
+     * @returns A new ClockTimeTz in the specified timezone
+     * @example
+     * ```ts
+     * const utc = ClockTimeTz.fromObject({ hour: 14, minute: 30 }, { zone: 'UTC' })
+     * const ny = utc.setZone('America/New_York')
+     * // Time is converted to New York timezone (e.g., 09:30 EST)
+     * ```
+     */
+    setZone(zone: string | Zone): ClockTimeTz;
+    protected static wrapLuxonError<T>(fn: () => T): T;
+    protected wrapLuxonError<T>(fn: () => T): T;
+}
+/**
+ * Thrown when a ClockTimeTz is invalid (e.g., invalid input or time values).
+ * @param error - The original error (available as cause)
+ * @example
+ * ```ts
+ * try {
+ *   ClockTimeTz.fromISO('25:00:00')
+ * } catch (e) {
+ *   if (e instanceof InvalidClockTimeTz) console.error(e.message)
+ * }
+ * ```
+ */
+export declare class InvalidClockTimeTz extends Error {
+    constructor(error: Error);
+}