class Duration(val years: Int = definedExternally, val months: Int = definedExternally, val weeks: Int = definedExternally, val days: Int = definedExternally, val hours: Int = definedExternally, val minutes: Int = definedExternally, val seconds: Int = definedExternally, val milliseconds: Int = definedExternally, val microseconds: Int = definedExternally, val nanoseconds: Int = definedExternally) : HasDurationOperations<Duration, DurationArithmeticOptions> , Localizable<DateTimeFormatOptions>

A Temporal.Duration represents an immutable duration of time which can be used in date/time arithmetic.

DurationArithmeticOptions

interface DurationArithmeticOptions

Options to control behavior of Duration.compare(), Duration.add(), and Duration.subtract()

DurationLike

interface DurationLike

DurationOptions

interface DurationOptions

Options for assigning fields using Duration.prototype.with() or entire objects with Duration.from(), and for arithmetic with Duration.prototype.add() and Duration.prototype.subtract().

Factory

sealed interface Factory<T : JsAny, in L : JsAny, in O : JsAny>

HasArithmeticOperations

sealed interface HasArithmeticOperations<T : HasArithmeticOperations<T, L, U>, in L : JsAny, U : DateTimeUnit<U>> : HasDurationOperations<T, ArithmeticOptions>

HasDurationOperations

sealed interface HasDurationOperations<T : HasDurationOperations<T, O>, in O : JsAny>

Instant

class Instant(val epochNanoseconds: BigInt) : HasArithmeticOperations<Instant, Nothing, TimeUnit<*>> , Roundable<Instant, TimeUnit<*>> , Localizable<DateTimeFormatOptions>

A Temporal.Instant is an exact point in time, with a precision in nanoseconds. No time zone or calendar information is present. Therefore, Temporal.Instant has no concept of days, months, or even hours.

InstantToStringOptions

interface InstantToStringOptions : ToStringPrecisionOptions

LargestUnit

sealed interface LargestUnit<out T : DateTimeUnit<T>>

LocalizableDateTime

typealias LocalizableDateTime = Localizable<DateTimeFormatOptions>

MonthCodeOrMonthAndYear

interface MonthCodeOrMonthAndYear : YearOrEraAndEraYear

MonthOrMonthCode

interface MonthOrMonthCode

Now

object Now

OffsetDisambiguationOptions

interface OffsetDisambiguationOptions

Overflow

sealed interface Overflow

PlainCompanion

sealed interface PlainCompanion<T : JsAny, in L : JsAny> : Factory<T, L, AssignmentOptions> , Comparator<T, L>

PlainDate

class PlainDate(isoYear: Int, isoMonth: Int, isoDay: Int, calendar: Calendar = definedExternally) : HasArithmeticOperations<PlainDate, PlainDateLike, DateUnit<*>> , Localizable<DateTimeFormatOptions>

A Temporal.PlainDate represents a calendar date. "Calendar date" refers to the concept of a date as expressed in everyday usage, independent of any time zone. For example, it could be used to represent an event on a calendar which happens during the whole day no matter which time zone it's happening in.

PlainDateISOFields

interface PlainDateISOFields

PlainDateLike

interface PlainDateLike

PlainDateTime

class PlainDateTime(isoYear: Int, isoMonth: Int, isoDay: Int, hour: Int = definedExternally, minute: Int = definedExternally, second: Int = definedExternally, millisecond: Int = definedExternally, microsecond: Int = definedExternally, nanosecond: Int = definedExternally, calendar: Calendar = definedExternally) : HasArithmeticOperations<PlainDateTime, PlainDateTimeLike, DateTimeUnit<*>> , Roundable<PlainDateTime, DateTimeUnit<*>> , Localizable<DateTimeFormatOptions>

A Temporal.PlainDateTime represents a calendar date and wall-clock time, with a precision in nanoseconds, and without any time zone. Of the Temporal classes carrying human-readable time information, it is the most general and complete one. Temporal.PlainDate, Temporal.PlainTime, Temporal.PlainYearMonth, and Temporal.PlainMonthDay all carry less information and should be used when complete information is not required.

PlainDateTimeISOFields

interface PlainDateTimeISOFields

PlainDateTimeLike

interface PlainDateTimeLike

PlainMonthDay

class PlainMonthDay(isoMonth: Int, isoDay: Int, calendar: Calendar = definedExternally, referenceISOYear: Int = definedExternally) : Localizable<DateTimeFormatOptions>

A Temporal.PlainMonthDay represents a particular day on the calendar, but without a year. For example, it could be used to represent a yearly recurring event, like "Bastille Day is on the 14th of July."

PlainMonthDayLike

interface PlainMonthDayLike

PlainTime

class PlainTime(val hour: Int = definedExternally, val minute: Int = definedExternally, val second: Int = definedExternally, val millisecond: Int = definedExternally, val microsecond: Int = definedExternally, val nanosecond: Int = definedExternally) : HasArithmeticOperations<PlainTime, PlainTimeLike, TimeUnit<*>> , Roundable<PlainTime, TimeUnit<*>> , Localizable<DateTimeFormatOptions>

A Temporal.PlainTime represents a wall-clock time, with a precision in nanoseconds, and without any time zone. "Wall-clock time" refers to the concept of a time as expressed in everyday usage — the time that you read off the clock on the wall. For example, it could be used to represent an event that happens daily at a certain time, no matter what time zone.

PlainTimeISOFields

interface PlainTimeISOFields

PlainTimeLike

interface PlainTimeLike

PlainYearMonth

class PlainYearMonth(isoYear: Int, isoMonth: Int, calendar: Calendar = definedExternally, referenceISODay: Int = definedExternally) : HasArithmeticOperations<PlainYearMonth, PlainYearMonthLike, DateUnit<*>> , Localizable<DateTimeFormatOptions>

A Temporal.PlainYearMonth represents a particular month on the calendar. For example, it could be used to represent a particular instance of a monthly recurring event, like "the June 2019 meeting".

PlainYearMonthLike

interface PlainYearMonthLike

PluralUnit

sealed interface PluralUnit<T : DateTimeUnit<T>> : LargestUnit<T> , SmallestUnit<T> , TotalUnit<T>

When the name of a unit is provided to a Temporal API as a string, it is usually singular, e.g. 'day' or 'hour'. But plural unit names like 'days' or 'hours' are aso accepted too.

Roundable

sealed interface Roundable<T : Roundable<T, U>, U : DateTimeUnit<U>>

RoundingMode

sealed interface RoundingMode

RoundTo

interface RoundTo<T : DateTimeUnit<T>>

round methods take one required parameter. If a string is provided, the resulting Temporal.Duration object will be rounded to that unit. If an object is provided, its smallestUnit property is required while other properties are optional. A string is treated the same as an object whose smallestUnit property value is that string.