warscript 0.0.1-dev.404878c

package/time/dayOfWeek.d.ts

@@ -0,0 +1,97 @@
+/** @noSelfInFile */
+import { BinaryReader } from "../binaryreader";
+import { BinaryWriter } from "../binarywriter";
+/**
+ * A day-of-week, such as 'Tuesday'.
+ * <p>
+ * {@code DayOfWeek} is a class representing the 7 days of the week -
+ * Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
+ * <p>
+ * This class represents a common concept that is found in many calendar systems.
+ * As such, this class may be used by any calendar system that has the day-of-week
+ * concept defined exactly equivalent to the ISO calendar system.
+ */
+export declare class DayOfWeek {
+    readonly value: number;
+    /**
+     * The singleton instance for the day-of-week of Monday.
+     * This has the numeric value of {@code 1}.
+     */
+    static readonly MONDAY: DayOfWeek;
+    /**
+     * The singleton instance for the day-of-week of Tuesday.
+     * This has the numeric value of {@code 2}.
+     */
+    static readonly TUESDAY: DayOfWeek;
+    /**
+     * The singleton instance for the day-of-week of Wednesday.
+     * This has the numeric value of {@code 3}.
+     */
+    static readonly WEDNESDAY: DayOfWeek;
+    /**
+     * The singleton instance for the day-of-week of Thursday.
+     * This has the numeric value of {@code 4}.
+     */
+    static readonly THURSDAY: DayOfWeek;
+    /**
+     * The singleton instance for the day-of-week of Friday.
+     * This has the numeric value of {@code 5}.
+     */
+    static readonly FRIDAY: DayOfWeek;
+    /**
+     * The singleton instance for the day-of-week of Saturday.
+     * This has the numeric value of {@code 6}.
+     */
+    static readonly SATURDAY: DayOfWeek;
+    /**
+     * The singleton instance for the day-of-week of Sunday.
+     * This has the numeric value of {@code 7}.
+     */
+    static readonly SUNDAY: DayOfWeek;
+    private constructor();
+    /**
+     * Obtains an instance of {@code DayOfWeek} from an {@code int} value.
+     * <p>
+     * {@code DayOfWeek} is a class representing the 7 days of the week.
+     * This factory allows the class to be obtained from the {@code int} value.
+     * The {@code int} value follows the ISO-8601 standard, from 1 (Monday) to 7 (Sunday).
+     *
+     * @param dayOfWeek  the day-of-week to represent, from 1 (Monday) to 7 (Sunday)
+     * @return the day-of-week singleton
+     */
+    static of(dayOfWeek: number): DayOfWeek;
+    static deserialize(reader: BinaryReader): DayOfWeek;
+    serialize(writer: BinaryWriter): void;
+    /**
+     * Returns the day-of-week that is the specified number of days after this one.
+     * <p>
+     * The calculation rolls around the end of the week from Sunday to Monday.
+     * The specified period may be negative.
+     * <p>
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param days  the days to add, positive or negative
+     * @return the resulting day-of-week
+     */
+    plus(days: number): DayOfWeek;
+    /**
+     * Returns the day-of-week that is the specified number of days before this one.
+     * <p>
+     * The calculation rolls around the start of the year from Monday to Sunday.
+     * The specified period may be negative.
+     * <p>
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param days  the days to subtract, positive or negative
+     * @return the resulting day-of-week
+     */
+    minus(days: number): DayOfWeek;
+    /**
+     * Outputs this day-of-week as a {@code string}.
+     *
+     * @return a string representation of this day-of-week
+     */
+    toString(): string;
+    private __lt;
+    private __le;
+}

package/time/dayOfWeek.lua

@@ -0,0 +1,53 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local ____exports = {}
+local cache = setmetatable({}, {__mode = "v"})
+--- A day-of-week, such as 'Tuesday'.
+-- <p>
+-- {@code DayOfWeek} is a class representing the 7 days of the week -
+-- Monday, Tuesday, Wednesday, Thursday, Friday, Saturday and Sunday.
+-- <p>
+-- This class represents a common concept that is found in many calendar systems.
+-- As such, this class may be used by any calendar system that has the day-of-week
+-- concept defined exactly equivalent to the ISO calendar system.
+____exports.DayOfWeek = __TS__Class()
+local DayOfWeek = ____exports.DayOfWeek
+DayOfWeek.name = "DayOfWeek"
+function DayOfWeek.prototype.____constructor(self, value)
+    self.value = value
+    assert(math.type(value) == "integer" and value >= 1 and value <= 7)
+    cache[value] = self
+end
+function DayOfWeek.of(self, dayOfWeek)
+    return cache[dayOfWeek] or __TS__New(____exports.DayOfWeek, dayOfWeek)
+end
+function DayOfWeek.deserialize(self, reader)
+    return ____exports.DayOfWeek:of(reader:readUInt8())
+end
+function DayOfWeek.prototype.serialize(self, writer)
+    writer:writeUInt8(self.value)
+end
+function DayOfWeek.prototype.plus(self, days)
+    return ____exports.DayOfWeek:of((self.value - 1 + (days % 7 + 7)) % 7 + 1)
+end
+function DayOfWeek.prototype.minus(self, days)
+    return self:plus(-(days % 7))
+end
+function DayOfWeek.prototype.__tostring(self)
+    return tostring(self.value)
+end
+function DayOfWeek.prototype.__lt(self, other)
+    return self.value < other.value
+end
+function DayOfWeek.prototype.__le(self, other)
+    return self.value <= other.value
+end
+DayOfWeek.MONDAY = ____exports.DayOfWeek:of(1)
+DayOfWeek.TUESDAY = ____exports.DayOfWeek:of(2)
+DayOfWeek.WEDNESDAY = ____exports.DayOfWeek:of(3)
+DayOfWeek.THURSDAY = ____exports.DayOfWeek:of(4)
+DayOfWeek.FRIDAY = ____exports.DayOfWeek:of(5)
+DayOfWeek.SATURDAY = ____exports.DayOfWeek:of(6)
+DayOfWeek.SUNDAY = ____exports.DayOfWeek:of(7)
+return ____exports

package/time/localDate.d.ts

@@ -0,0 +1,145 @@
+/** @noSelfInFile */
+import { DayOfWeek } from "./dayOfWeek";
+import { Month } from "./month";
+export declare class LocalDate {
+    readonly year: number;
+    readonly month: Month;
+    readonly dayOfMonth: number;
+    private readonly key;
+    private constructor();
+    static now(): LocalDate;
+    static of(year: number, month: number | Month, day: number): LocalDate;
+    /**
+     * Obtains an instance of {@code LocalDate} from the epoch day count.
+     * <p>
+     * This returns a {@code LocalDate} with the specified epoch-day.
+     * The epoch-day is a simple incrementing count
+     * of days where day 0 is 1970-01-01. Negative numbers represent earlier days.
+     *
+     * @param epochDay  the Epoch Day to convert, based on the epoch 1970-01-01
+     * @return the local date
+     */
+    private static ofEpochDay;
+    /**
+     * Resolves the date, resolving days past the end of month.
+     *
+     * @param year  the year to represent, validated from MIN_YEAR to MAX_YEAR
+     * @param month  the month-of-year to represent, validated from 1 to 12
+     * @param day  the day-of-month to represent, validated from 1 to 31
+     * @return the resolved date
+     */
+    private static resolvePreviousValid;
+    /**
+     * Gets the day-of-year field.
+     * <p>
+     * This method returns the primitive {@code int} value for the day-of-year.
+     *
+     * @return the day-of-year, from 1 to 365, or 366 in a leap year
+     */
+    get dayOfYear(): number;
+    /**
+     * Gets the day-of-week field, which is a class {@code DayOfWeek}.
+     * <p>
+     * This method returns the class {@link DayOfWeek} for the day-of-week.
+     *
+     * @return the day-of-week
+     */
+    get dayOfWeek(): DayOfWeek;
+    /**
+     * Checks if the year is a leap year, according to the ISO proleptic
+     * calendar system rules.
+     * <p>
+     * This method applies the current rules for leap years across the whole time-line.
+     * In general, a year is a leap year if it is divisible by four without
+     * remainder. However, years divisible by 100, are not leap years, with
+     * the exception of years divisible by 400 which are.
+     * <p>
+     * For example, 1904 is a leap year it is divisible by 4.
+     * 1900 was not a leap year as it is divisible by 100, however 2000 was a
+     * leap year as it is divisible by 400.
+     * <p>
+     * The calculation is proleptic - applying the same rules into the far future and far past.
+     * This is historically inaccurate, but is correct for the ISO-8601 standard.
+     *
+     * @return true if the year is leap, false otherwise
+     */
+    get isLeapYear(): boolean;
+    /**
+     * Returns the length of the month represented by this date.
+     * <p>
+     * This returns the length of the month in days.
+     * For example, a date in January would return 31.
+     *
+     * @return the length of the month in days
+     */
+    get lengthOfMonth(): number;
+    /**
+     * Returns the length of the year represented by this date.
+     * <p>
+     * This returns the length of the year in days, either 365 or 366.
+     *
+     * @return 366 if the year is leap, 365 otherwise
+     */
+    get lengthOfYear(): number;
+    /**
+     * Returns a copy of this {@code LocalDate} with the specified number of months added.
+     * <p>
+     * This method adds the specified amount to the months field in three steps:
+     * <ol>
+     * <li>Add the input months to the month-of-year field</li>
+     * <li>Check if the resulting date would be invalid</li>
+     * <li>Adjust the day-of-month to the last valid day if necessary</li>
+     * </ol>
+     * <p>
+     * For example, 2007-03-31 plus one month would result in the invalid date
+     * 2007-04-31. Instead of returning an invalid result, the last valid day
+     * of the month, 2007-04-30, is selected instead.
+     * <p>
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param monthsToAdd  the months to add, may be negative
+     * @return a {@code LocalDate} based on this date with the months added, not null
+     */
+    plusMonths(monthsToAdd: number): LocalDate;
+    /**
+     * Returns a copy of this {@code LocalDate} with the specified number of weeks added.
+     * <p>
+     * This method adds the specified amount in weeks to the days field incrementing
+     * the month and year fields as necessary to ensure the result remains valid.
+     * The result is only invalid if the maximum/minimum year is exceeded.
+     * <p>
+     * For example, 2008-12-31 plus one week would result in 2009-01-07.
+     * <p>
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param weeksToAdd  the weeks to add, may be negative
+     * @return a {@code LocalDate} based on this date with the weeks added
+     */
+    plusWeeks(weeksToAdd: number): LocalDate;
+    /**
+     * Returns a copy of this {@code LocalDate} with the specified number of days added.
+     * <p>
+     * This method adds the specified amount to the days field incrementing the
+     * month and year fields as necessary to ensure the result remains valid.
+     * The result is only invalid if the maximum/minimum year is exceeded.
+     * <p>
+     * For example, 2008-12-31 plus one day would result in 2009-01-01.
+     * <p>
+     * This instance is immutable and unaffected by this method call.
+     *
+     * @param daysToAdd  the days to add, may be negative
+     * @return a {@code LocalDate} based on this date with the days added
+     */
+    plusDays(daysToAdd: number): LocalDate;
+    private toEpochDay;
+    /**
+     * Outputs this date as a {@code String}, such as {@code 2007-12-03}.
+     * <p>
+     * The output will be in the ISO-8601 format {@code uuuu-MM-dd}.
+     *
+     * @return a string representation of this date
+     */
+    toString(): string;
+    private __lt;
+    private __le;
+}

package/time/localDate.lua

@@ -0,0 +1,236 @@
+local ____lualib = require("lualib_bundle")
+local __TS__Class = ____lualib.__TS__Class
+local __TS__New = ____lualib.__TS__New
+local __TS__SetDescriptor = ____lualib.__TS__SetDescriptor
+local ____exports = {}
+local ____dayOfWeek = require("time.dayOfWeek")
+local DayOfWeek = ____dayOfWeek.DayOfWeek
+local ____month = require("time.month")
+local Month = ____month.Month
+local ____year = require("time.year")
+local Year = ____year.Year
+local ____stringBuilder = require("util.stringBuilder")
+local StringBuilder = ____stringBuilder.StringBuilder
+local date = os.date
+local format = string.format
+local pack = string.pack
+local abs = math.abs
+local cache = setmetatable({}, {__mode = "v"})
+--- The number of days in a 400-year cycle.
+local DAYS_PER_CYCLE = 146097
+--- The number of days from year zero to year 1970.
+-- There are five 400 year cycles from year zero to 2000.
+-- There are 7 leap years from 1970 to 2000.
+local DAYS_0000_TO_1970 = DAYS_PER_CYCLE * 5 - (30 * 365 + 7)
+____exports.LocalDate = __TS__Class()
+local LocalDate = ____exports.LocalDate
+LocalDate.name = "LocalDate"
+function LocalDate.prototype.____constructor(self, year, month, dayOfMonth, key)
+    self.year = year
+    self.month = month
+    self.dayOfMonth = dayOfMonth
+    self.key = key
+    assert(math.type(year) == "integer")
+    assert(math.type(dayOfMonth) == "integer" and dayOfMonth >= 1 and dayOfMonth <= 31)
+    cache[key] = self
+end
+function LocalDate.now(self)
+    local info = date("*t")
+    return ____exports.LocalDate:of(info.year, info.month, info.day)
+end
+function LocalDate.of(self, year, month, day)
+    month = type(month) == "number" and month or month.value
+    local key = pack(">i4BB", year, month, day)
+    return cache[key] or __TS__New(
+        ____exports.LocalDate,
+        year,
+        Month:of(month),
+        day,
+        key
+    )
+end
+function LocalDate.ofEpochDay(self, epochDay)
+    local zeroDay = epochDay + DAYS_0000_TO_1970
+    zeroDay = zeroDay - 60
+    local adjust = 0
+    if zeroDay < 0 then
+        local adjustCycles = (zeroDay + 1) // DAYS_PER_CYCLE - 1
+        adjust = adjustCycles * 400
+        zeroDay = zeroDay + -adjustCycles * DAYS_PER_CYCLE
+    end
+    local yearEst = (400 * zeroDay + 591) // DAYS_PER_CYCLE
+    local doyEst = zeroDay - (365 * yearEst + yearEst // 4 - yearEst // 100 + yearEst // 400)
+    if doyEst < 0 then
+        yearEst = yearEst - 1
+        doyEst = zeroDay - (365 * yearEst + yearEst // 4 - yearEst // 100 + yearEst // 400)
+    end
+    yearEst = yearEst + adjust
+    local marchDoy0 = doyEst
+    local marchMonth0 = (marchDoy0 * 5 + 2) // 153
+    local month = (marchMonth0 + 2) % 12 + 1
+    local dom = marchDoy0 - (marchMonth0 * 306 + 5) // 10 + 1
+    yearEst = yearEst + marchMonth0 // 10
+    return ____exports.LocalDate:of(yearEst, month, dom)
+end
+function LocalDate.resolvePreviousValid(self, year, month, day)
+    repeat
+        local ____switch9 = month
+        local ____cond9 = ____switch9 == 2
+        if ____cond9 then
+            day = math.min(
+                day,
+                Year:isLeap(year) and 29 or 28
+            )
+            break
+        end
+        ____cond9 = ____cond9 or (____switch9 == 4 or ____switch9 == 6 or ____switch9 == 9 or ____switch9 == 11)
+        if ____cond9 then
+            day = math.min(day, 30)
+            break
+        end
+    until true
+    return ____exports.LocalDate:of(year, month, day)
+end
+function LocalDate.prototype.plusMonths(self, monthsToAdd)
+    assert(math.type(monthsToAdd) == "integer")
+    if monthsToAdd == 0 then
+        return self
+    end
+    local monthCount = self.year * 12 + (self.month.value - 1)
+    local calcMonths = monthCount + monthsToAdd
+    local newYear = calcMonths // 12
+    local newMonth = math.fmod(calcMonths, 12) + 1
+    return ____exports.LocalDate:resolvePreviousValid(newYear, newMonth, self.dayOfMonth)
+end
+function LocalDate.prototype.plusWeeks(self, weeksToAdd)
+    return self:plusDays(weeksToAdd * 7)
+end
+function LocalDate.prototype.plusDays(self, daysToAdd)
+    assert(math.type(daysToAdd) == "integer")
+    if daysToAdd == 0 then
+        return self
+    end
+    local dom = self.dayOfMonth + daysToAdd
+    if dom > 0 then
+        if dom <= 28 then
+            return ____exports.LocalDate:of(self.year, self.month.value, dom)
+        elseif dom <= 59 then
+            local monthLen = self.lengthOfMonth
+            if dom <= monthLen then
+                return ____exports.LocalDate:of(self.year, self.month.value, dom)
+            elseif self.month.value < 12 then
+                return ____exports.LocalDate:of(self.year, self.month.value + 1, dom - monthLen)
+            else
+                return ____exports.LocalDate:of(self.year + 1, 1, dom - monthLen)
+            end
+        end
+    end
+    local mjDay = self:toEpochDay() + daysToAdd
+    return ____exports.LocalDate:ofEpochDay(mjDay)
+end
+function LocalDate.prototype.toEpochDay(self)
+    local y = self.year
+    local m = self.month.value
+    local total = 0
+    total = total + 365 * y
+    if y >= 0 then
+        total = total + ((y + 3) // 4 - (y + 99) // 100 + (y + 399) // 400)
+    else
+        total = total - (y // -4 - y // -100 + y // -400)
+    end
+    total = total + (367 * m - 362) // 12
+    total = total + (self.dayOfMonth - 1)
+    if m > 2 then
+        total = total - 1
+        if not self.isLeapYear then
+            total = total - 1
+        end
+    end
+    return total - DAYS_0000_TO_1970
+end
+function LocalDate.prototype.__tostring(self)
+    local year = self.year
+    local month = self.month.value
+    local day = self.dayOfMonth
+    local sb = __TS__New(StringBuilder)
+    if abs(year) < 1000 then
+        if year < 0 then
+            sb:append(format(
+                "-%04d",
+                abs(year)
+            ))
+        else
+            sb:append(format("%04d", year))
+        end
+    else
+        if year > 9999 then
+            sb:append("+")
+        end
+        sb:append(year)
+    end
+    return tostring(sb:append(month < 10 and "-0" or "-"):append(month):append(day < 10 and "-0" or "-"):append(day))
+end
+function LocalDate.prototype.__lt(self, other)
+    local cmp = self.year - other.year
+    if cmp == 0 then
+        cmp = self.month.value - other.month.value
+        if cmp == 0 then
+            cmp = self.dayOfMonth - other.dayOfMonth
+        end
+    end
+    return cmp < 0
+end
+function LocalDate.prototype.__le(self, other)
+    local cmp = self.year - other.year
+    if cmp == 0 then
+        cmp = self.month.value - other.month.value
+        if cmp == 0 then
+            cmp = self.dayOfMonth - other.dayOfMonth
+        end
+    end
+    return cmp <= 0
+end
+__TS__SetDescriptor(
+    LocalDate.prototype,
+    "dayOfYear",
+    {get = function(self)
+        return self.month:getFirstDayOfYear(self.isLeapYear) + self.dayOfMonth - 1
+    end},
+    true
+)
+__TS__SetDescriptor(
+    LocalDate.prototype,
+    "dayOfWeek",
+    {get = function(self)
+        return DayOfWeek:of(math.fmod(
+            self:toEpochDay() + 3,
+            7
+        ) + 1)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    LocalDate.prototype,
+    "isLeapYear",
+    {get = function(self)
+        return Year:isLeap(self.year)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    LocalDate.prototype,
+    "lengthOfMonth",
+    {get = function(self)
+        return self.month:getLength(self.isLeapYear)
+    end},
+    true
+)
+__TS__SetDescriptor(
+    LocalDate.prototype,
+    "lengthOfYear",
+    {get = function(self)
+        return self.isLeapYear and 366 or 365
+    end},
+    true
+)
+return ____exports

package/time/localDateTime.d.ts

@@ -0,0 +1,133 @@
+/** @noSelfInFile */
+import { BinaryReader } from "../binaryreader";
+import { BinaryWriter } from "../binarywriter";
+import { DayOfWeek } from "./dayOfWeek";
+import { Month } from "./month";
+import { LocalDate } from "./localDate";
+import { LocalTime } from "./localTime";
+export declare class LocalDateTime {
+    private readonly date;
+    private readonly time;
+    private readonly key;
+    private constructor();
+    static now(this: void): LocalDateTime;
+    /**
+     * Obtains an instance of {@code LocalDateTime} from year, month,
+     * day, hour, minute and second.
+     * <p>
+     * This returns a {@code LocalDateTime} with the specified year, month,
+     * day-of-month, hour and minute.
+     * The day must be valid for the year and month, otherwise an exception will be thrown.
+     *
+     * @param year  the year to represent, from MIN_YEAR to MAX_YEAR
+     * @param month  the month-of-year to represent
+     * @param dayOfMonth  the day-of-month to represent, from 1 to 31
+     * @param hour  the hour-of-day to represent, from 0 to 23
+     * @param minute  the minute-of-hour to represent, from 0 to 59
+     * @param second  the second-of-minute to represent, from 0 to 59
+     * @return the local date-time
+     */
+    static of(year: number, month: number | Month, dayOfMonth: number, hour: number, minute: number, second?: number): LocalDateTime;
+    /**
+     * Obtains an instance of {@code LocalDateTime} using seconds from the
+     * epoch of 1970-01-01T00:00:00Z.
+     *
+     * @param epochSecond  the number of seconds from the epoch of 1970-01-01T00:00:00Z
+     * @return the local date-time
+     */
+    static ofEpochSecond(epochSecond: number): LocalDateTime;
+    static deserialize(reader: BinaryReader): LocalDateTime;
+    serialize(writer: BinaryWriter): void;
+    /**
+     * Gets the {@code LocalDate} part of this date-time.
+     * <p>
+     * This returns a {@code LocalDate} with the same year, month and day
+     * as this date-time.
+     *
+     * @return the date part of this date-time
+     */
+    toLocalDate(): LocalDate;
+    /**
+     * Gets the year field.
+     * <p>
+     * This method returns the primitive {@code number} value for the year.
+     *
+     * @return the year, from MIN_YEAR to MAX_YEAR
+     */
+    get year(): number;
+    /**
+     * Gets the month-of-year field using the {@code Month} enum.
+     * <p>
+     * This method returns the class {@link Month} for the month.
+     *
+     * @return the month-of-year
+     */
+    get month(): Month;
+    /**
+     * Gets the day-of-month field.
+     * <p>
+     * This method returns the primitive {@code number} value for the day-of-month.
+     *
+     * @return the day-of-month, from 1 to 31
+     */
+    get dayOfMonth(): number;
+    /**
+     * Gets the day-of-year field.
+     * <p>
+     * This method returns the primitive {@code number} value for the day-of-year.
+     *
+     * @return the day-of-year, from 1 to 365, or 366 in a leap year
+     */
+    get dayOfYear(): number;
+    /**
+     * Gets the day-of-week field, which is a class {@code DayOfWeek}.
+     * <p>
+     * This method returns the class {@link DayOfWeek} for the day-of-week.
+     *
+     * @return the day-of-week
+     */
+    get dayOfWeek(): DayOfWeek;
+    /**
+     * Gets the {@code LocalTime} part of this date-time.
+     * <p>
+     * This returns a {@code LocalTime} with the same hour, minute, second and
+     * nanosecond as this date-time.
+     *
+     * @return the time part of this date-time
+     */
+    toLocalTime(): LocalTime;
+    /**
+     * Gets the hour-of-day field.
+     *
+     * @return the hour-of-day, from 0 to 23
+     */
+    get hour(): number;
+    /**
+     * Gets the minute-of-hour field.
+     *
+     * @return the minute-of-hour, from 0 to 59
+     */
+    get minute(): number;
+    /**
+     * Gets the second-of-minute field.
+     *
+     * @return the second-of-minute, from 0 to 59
+     */
+    get second(): number;
+    /**
+     * Outputs this date-time as a {@code String}, such as {@code 2007-12-03T10:15:30}.
+     * <p>
+     * The output will be one of the following ISO-8601 formats:
+     * <ul>
+     * <li>{@code uuuu-MM-dd'T'HH:mm}</li>
+     * <li>{@code uuuu-MM-dd'T'HH:mm:ss}</li>
+     * </ul>
+     * The format used will be the shortest that outputs the full value of
+     * the time where the omitted parts are implied to be zero.
+     *
+     * @return a string representation of this date-time
+     */
+    toString(): string;
+    private __lt;
+    private __le;
+}