mirror of
https://github.com/microsoft/TypeScript.git
synced 2026-04-13 18:00:32 -05:00
486 lines
22 KiB
TypeScript
486 lines
22 KiB
TypeScript
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
|
|
this file except in compliance with the License. You may obtain a copy of the
|
|
License at http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
MERCHANTABILITY OR NON-INFRINGEMENT.
|
|
|
|
See the Apache Version 2.0 License for specific language governing permissions
|
|
and limitations under the License.
|
|
***************************************************************************** */
|
|
|
|
|
|
/// <reference lib="es2015.symbol.wellknown" />
|
|
/// <reference lib="es2020.intl" />
|
|
/// <reference lib="es2025.intl" />
|
|
|
|
declare namespace Temporal {
|
|
type CalendarLike = PlainDate | PlainDateTime | PlainMonthDay | PlainYearMonth | ZonedDateTime | string;
|
|
type DurationLike = Duration | DurationLikeObject | string;
|
|
type InstantLike = Instant | ZonedDateTime | string;
|
|
type PlainDateLike = PlainDate | ZonedDateTime | PlainDateTime | DateLikeObject | string;
|
|
type PlainDateTimeLike = PlainDateTime | ZonedDateTime | PlainDate | DateTimeLikeObject | string;
|
|
type PlainMonthDayLike = PlainMonthDay | DateLikeObject | string;
|
|
type PlainTimeLike = PlainTime | PlainDateTime | ZonedDateTime | TimeLikeObject | string;
|
|
type PlainYearMonthLike = PlainYearMonth | YearMonthLikeObject | string;
|
|
type TimeZoneLike = ZonedDateTime | string;
|
|
type ZonedDateTimeLike = ZonedDateTime | ZonedDateTimeLikeObject | string;
|
|
|
|
type PartialTemporalLike<T extends object> = {
|
|
[P in Exclude<keyof T, "calendar" | "timeZone">]?: T[P] | undefined;
|
|
};
|
|
|
|
interface DateLikeObject {
|
|
year?: number | undefined;
|
|
era?: string | undefined;
|
|
eraYear?: number | undefined;
|
|
month?: number | undefined;
|
|
monthCode?: string | undefined;
|
|
day: number;
|
|
calendar?: string | undefined;
|
|
}
|
|
|
|
interface DateTimeLikeObject extends DateLikeObject, TimeLikeObject {}
|
|
|
|
interface DurationLikeObject {
|
|
years?: number | undefined;
|
|
months?: number | undefined;
|
|
weeks?: number | undefined;
|
|
days?: number | undefined;
|
|
hours?: number | undefined;
|
|
minutes?: number | undefined;
|
|
seconds?: number | undefined;
|
|
milliseconds?: number | undefined;
|
|
microseconds?: number | undefined;
|
|
nanoseconds?: number | undefined;
|
|
}
|
|
|
|
interface TimeLikeObject {
|
|
hour?: number | undefined;
|
|
minute?: number | undefined;
|
|
second?: number | undefined;
|
|
millisecond?: number | undefined;
|
|
microsecond?: number | undefined;
|
|
nanosecond?: number | undefined;
|
|
}
|
|
|
|
interface YearMonthLikeObject extends Omit<DateLikeObject, "day"> {}
|
|
|
|
interface ZonedDateTimeLikeObject extends DateTimeLikeObject {
|
|
timeZone: TimeZoneLike;
|
|
offset?: string | undefined;
|
|
}
|
|
|
|
type DateUnit = "year" | "month" | "week" | "day";
|
|
type TimeUnit = "hour" | "minute" | "second" | "millisecond" | "microsecond" | "nanosecond";
|
|
type PluralizeUnit<T extends DateUnit | TimeUnit> =
|
|
| T
|
|
| {
|
|
year: "years";
|
|
month: "months";
|
|
week: "weeks";
|
|
day: "days";
|
|
hour: "hours";
|
|
minute: "minutes";
|
|
second: "seconds";
|
|
millisecond: "milliseconds";
|
|
microsecond: "microseconds";
|
|
nanosecond: "nanoseconds";
|
|
}[T];
|
|
|
|
interface DisambiguationOptions {
|
|
disambiguation?: "compatible" | "earlier" | "later" | "reject" | undefined;
|
|
}
|
|
|
|
interface OverflowOptions {
|
|
overflow?: "constrain" | "reject" | undefined;
|
|
}
|
|
|
|
interface TransitionOptions {
|
|
direction: "next" | "previous";
|
|
}
|
|
|
|
interface RoundingOptions<Units extends DateUnit | TimeUnit> {
|
|
smallestUnit?: PluralizeUnit<Units> | undefined;
|
|
roundingIncrement?: number | undefined;
|
|
roundingMode?: "ceil" | "floor" | "expand" | "trunc" | "halfCeil" | "halfFloor" | "halfExpand" | "halfTrunc" | "halfEven" | undefined;
|
|
}
|
|
|
|
interface RoundingOptionsWithLargestUnit<Units extends DateUnit | TimeUnit> extends RoundingOptions<Units> {
|
|
largestUnit?: "auto" | PluralizeUnit<Units> | undefined;
|
|
}
|
|
|
|
interface ToStringRoundingOptions<Units extends DateUnit | TimeUnit> extends Pick<RoundingOptions<Units>, "smallestUnit" | "roundingMode"> {}
|
|
|
|
interface ToStringRoundingOptionsWithFractionalSeconds<Units extends DateUnit | TimeUnit> extends ToStringRoundingOptions<Units> {
|
|
fractionalSecondDigits?: "auto" | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | undefined;
|
|
}
|
|
|
|
namespace Now {
|
|
function timeZoneId(): string;
|
|
function instant(): Instant;
|
|
function plainDateTimeISO(timeZone?: TimeZoneLike): PlainDateTime;
|
|
function zonedDateTimeISO(timeZone?: TimeZoneLike): ZonedDateTime;
|
|
function plainDateISO(timeZone?: TimeZoneLike): PlainDate;
|
|
function plainTimeISO(timeZone?: TimeZoneLike): PlainTime;
|
|
}
|
|
|
|
interface PlainDateToStringOptions {
|
|
calendarName?: "auto" | "always" | "never" | "critical" | undefined;
|
|
}
|
|
|
|
interface PlainDateToZonedDateTimeOptions {
|
|
plainTime?: PlainTimeLike | undefined;
|
|
timeZone: TimeZoneLike;
|
|
}
|
|
|
|
interface PlainDate {
|
|
readonly calendarId: string;
|
|
readonly era: string | undefined;
|
|
readonly eraYear: number | undefined;
|
|
readonly year: number;
|
|
readonly month: number;
|
|
readonly monthCode: string;
|
|
readonly day: number;
|
|
readonly dayOfWeek: number;
|
|
readonly dayOfYear: number;
|
|
readonly weekOfYear: number | undefined;
|
|
readonly yearOfWeek: number | undefined;
|
|
readonly daysInWeek: number;
|
|
readonly daysInMonth: number;
|
|
readonly daysInYear: number;
|
|
readonly monthsInYear: number;
|
|
readonly inLeapYear: boolean;
|
|
toPlainYearMonth(): PlainYearMonth;
|
|
toPlainMonthDay(): PlainMonthDay;
|
|
add(duration: DurationLike, options?: OverflowOptions): PlainDate;
|
|
subtract(duration: DurationLike, options?: OverflowOptions): PlainDate;
|
|
with(dateLike: PartialTemporalLike<DateLikeObject>, options?: OverflowOptions): PlainDate;
|
|
withCalendar(calendarLike: CalendarLike): PlainDate;
|
|
until(other: PlainDateLike, options?: RoundingOptionsWithLargestUnit<DateUnit>): Duration;
|
|
since(other: PlainDateLike, options?: RoundingOptionsWithLargestUnit<DateUnit>): Duration;
|
|
equals(other: PlainDateLike): boolean;
|
|
toPlainDateTime(time?: PlainTimeLike): PlainDateTime;
|
|
toZonedDateTime(timeZone: TimeZoneLike): ZonedDateTime;
|
|
toZonedDateTime(item: PlainDateToZonedDateTimeOptions): ZonedDateTime;
|
|
toString(options?: PlainDateToStringOptions): string;
|
|
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
|
toJSON(): string;
|
|
valueOf(): never;
|
|
readonly [Symbol.toStringTag]: "Temporal.PlainDate";
|
|
}
|
|
|
|
interface PlainDateConstructor {
|
|
new (isoYear: number, isoMonth: number, isoDay: number, calendar?: string): PlainDate;
|
|
readonly prototype: PlainDate;
|
|
from(item: PlainDateLike, options?: OverflowOptions): PlainDate;
|
|
compare(one: PlainDateLike, two: PlainDateLike): number;
|
|
}
|
|
var PlainDate: PlainDateConstructor;
|
|
|
|
interface PlainTimeToStringOptions extends ToStringRoundingOptionsWithFractionalSeconds<Exclude<TimeUnit, "hour">> {}
|
|
|
|
interface PlainTime {
|
|
readonly hour: number;
|
|
readonly minute: number;
|
|
readonly second: number;
|
|
readonly millisecond: number;
|
|
readonly microsecond: number;
|
|
readonly nanosecond: number;
|
|
add(duration: DurationLike): PlainTime;
|
|
subtract(duration: DurationLike): PlainTime;
|
|
with(timeLike: PartialTemporalLike<TimeLikeObject>, options?: OverflowOptions): PlainTime;
|
|
until(other: PlainTimeLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
|
|
since(other: PlainTimeLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
|
|
equals(other: PlainTimeLike): boolean;
|
|
round(roundTo: PluralizeUnit<TimeUnit>): PlainTime;
|
|
round(roundTo: RoundingOptions<TimeUnit>): PlainTime;
|
|
toString(options?: PlainTimeToStringOptions): string;
|
|
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
|
toJSON(): string;
|
|
valueOf(): never;
|
|
readonly [Symbol.toStringTag]: "Temporal.PlainTime";
|
|
}
|
|
|
|
interface PlainTimeConstructor {
|
|
new (hour?: number, minute?: number, second?: number, millisecond?: number, microsecond?: number, nanosecond?: number): PlainTime;
|
|
readonly prototype: PlainTime;
|
|
from(item: PlainTimeLike, options?: OverflowOptions): PlainTime;
|
|
compare(one: PlainTimeLike, two: PlainTimeLike): number;
|
|
}
|
|
var PlainTime: PlainTimeConstructor;
|
|
|
|
interface PlainDateTimeToStringOptions extends PlainDateToStringOptions, PlainTimeToStringOptions {}
|
|
|
|
interface PlainDateTime {
|
|
readonly calendarId: string;
|
|
readonly era: string | undefined;
|
|
readonly eraYear: number | undefined;
|
|
readonly year: number;
|
|
readonly month: number;
|
|
readonly monthCode: string;
|
|
readonly day: number;
|
|
readonly hour: number;
|
|
readonly minute: number;
|
|
readonly second: number;
|
|
readonly millisecond: number;
|
|
readonly microsecond: number;
|
|
readonly nanosecond: number;
|
|
readonly dayOfWeek: number;
|
|
readonly dayOfYear: number;
|
|
readonly weekOfYear: number | undefined;
|
|
readonly yearOfWeek: number | undefined;
|
|
readonly daysInWeek: number;
|
|
readonly daysInMonth: number;
|
|
readonly daysInYear: number;
|
|
readonly monthsInYear: number;
|
|
readonly inLeapYear: boolean;
|
|
with(dateTimeLike: PartialTemporalLike<DateTimeLikeObject>, options?: OverflowOptions): PlainDateTime;
|
|
withPlainTime(plainTime?: PlainTimeLike): PlainDateTime;
|
|
withCalendar(calendar: CalendarLike): PlainDateTime;
|
|
add(duration: DurationLike, options?: OverflowOptions): PlainDateTime;
|
|
subtract(duration: DurationLike, options?: OverflowOptions): PlainDateTime;
|
|
until(other: PlainDateTimeLike, options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>): Duration;
|
|
since(other: PlainDateTimeLike, options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>): Duration;
|
|
round(roundTo: PluralizeUnit<"day" | TimeUnit>): PlainDateTime;
|
|
round(roundTo: RoundingOptions<"day" | TimeUnit>): PlainDateTime;
|
|
equals(other: PlainDateTimeLike): boolean;
|
|
toString(options?: PlainDateTimeToStringOptions): string;
|
|
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
|
toJSON(): string;
|
|
valueOf(): never;
|
|
toZonedDateTime(timeZone: TimeZoneLike, options?: DisambiguationOptions): ZonedDateTime;
|
|
toPlainDate(): PlainDate;
|
|
toPlainTime(): PlainTime;
|
|
readonly [Symbol.toStringTag]: "Temporal.PlainDateTime";
|
|
}
|
|
|
|
interface PlainDateTimeConstructor {
|
|
new (isoYear: number, isoMonth: number, isoDay: number, hour?: number, minute?: number, second?: number, millisecond?: number, microsecond?: number, nanosecond?: number, calendar?: string): PlainDateTime;
|
|
readonly prototype: PlainDateTime;
|
|
from(item: PlainDateTimeLike, options?: OverflowOptions): PlainDateTime;
|
|
compare(one: PlainDateTimeLike, two: PlainDateTimeLike): number;
|
|
}
|
|
var PlainDateTime: PlainDateTimeConstructor;
|
|
|
|
interface ZonedDateTimeToStringOptions extends PlainDateTimeToStringOptions {
|
|
offset?: "auto" | "never" | undefined;
|
|
timeZoneName?: "auto" | "never" | "critical" | undefined;
|
|
}
|
|
|
|
interface ZonedDateTimeFromOptions extends OverflowOptions, DisambiguationOptions {
|
|
offset?: "use" | "ignore" | "prefer" | "reject" | undefined;
|
|
}
|
|
|
|
interface ZonedDateTime {
|
|
readonly calendarId: string;
|
|
readonly timeZoneId: string;
|
|
readonly era: string | undefined;
|
|
readonly eraYear: number | undefined;
|
|
readonly year: number;
|
|
readonly month: number;
|
|
readonly monthCode: string;
|
|
readonly day: number;
|
|
readonly hour: number;
|
|
readonly minute: number;
|
|
readonly second: number;
|
|
readonly millisecond: number;
|
|
readonly microsecond: number;
|
|
readonly nanosecond: number;
|
|
readonly epochMilliseconds: number;
|
|
readonly epochNanoseconds: bigint;
|
|
readonly dayOfWeek: number;
|
|
readonly dayOfYear: number;
|
|
readonly weekOfYear: number | undefined;
|
|
readonly yearOfWeek: number | undefined;
|
|
readonly hoursInDay: number;
|
|
readonly daysInWeek: number;
|
|
readonly daysInMonth: number;
|
|
readonly daysInYear: number;
|
|
readonly monthsInYear: number;
|
|
readonly inLeapYear: boolean;
|
|
readonly offsetNanoseconds: number;
|
|
readonly offset: string;
|
|
with(zonedDateTimeLike: PartialTemporalLike<ZonedDateTimeLikeObject>, options?: ZonedDateTimeFromOptions): ZonedDateTime;
|
|
withPlainTime(plainTime?: PlainTimeLike): ZonedDateTime;
|
|
withTimeZone(timeZone: TimeZoneLike): ZonedDateTime;
|
|
withCalendar(calendar: CalendarLike): ZonedDateTime;
|
|
add(duration: DurationLike, options?: OverflowOptions): ZonedDateTime;
|
|
subtract(duration: DurationLike, options?: OverflowOptions): ZonedDateTime;
|
|
until(other: ZonedDateTimeLike, options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>): Duration;
|
|
since(other: ZonedDateTimeLike, options?: RoundingOptionsWithLargestUnit<DateUnit | TimeUnit>): Duration;
|
|
round(roundTo: PluralizeUnit<"day" | TimeUnit>): ZonedDateTime;
|
|
round(roundTo: RoundingOptions<"day" | TimeUnit>): ZonedDateTime;
|
|
equals(other: ZonedDateTimeLike): boolean;
|
|
toString(options?: ZonedDateTimeToStringOptions): string;
|
|
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
|
toJSON(): string;
|
|
valueOf(): never;
|
|
startOfDay(): ZonedDateTime;
|
|
getTimeZoneTransition(direction: "next" | "previous"): ZonedDateTime | null;
|
|
getTimeZoneTransition(direction: TransitionOptions): ZonedDateTime | null;
|
|
toInstant(): Instant;
|
|
toPlainDate(): PlainDate;
|
|
toPlainTime(): PlainTime;
|
|
toPlainDateTime(): PlainDateTime;
|
|
readonly [Symbol.toStringTag]: "Temporal.ZonedDateTime";
|
|
}
|
|
|
|
interface ZonedDateTimeConstructor {
|
|
new (epochNanoseconds: bigint, timeZone: string, calendar?: string): ZonedDateTime;
|
|
readonly prototype: ZonedDateTime;
|
|
from(item: ZonedDateTimeLike, options?: ZonedDateTimeFromOptions): ZonedDateTime;
|
|
compare(one: ZonedDateTimeLike, two: ZonedDateTimeLike): number;
|
|
}
|
|
var ZonedDateTime: ZonedDateTimeConstructor;
|
|
|
|
interface DurationRelativeToOptions {
|
|
relativeTo?: ZonedDateTimeLike | PlainDateLike | undefined;
|
|
}
|
|
|
|
interface DurationRoundingOptions extends DurationRelativeToOptions, RoundingOptionsWithLargestUnit<DateUnit | TimeUnit> {}
|
|
|
|
interface DurationToStringOptions extends ToStringRoundingOptionsWithFractionalSeconds<Exclude<TimeUnit, "hour" | "minute">> {}
|
|
|
|
interface DurationTotalOptions extends DurationRelativeToOptions {
|
|
unit: PluralizeUnit<DateUnit | TimeUnit>;
|
|
}
|
|
|
|
interface Duration {
|
|
readonly years: number;
|
|
readonly months: number;
|
|
readonly weeks: number;
|
|
readonly days: number;
|
|
readonly hours: number;
|
|
readonly minutes: number;
|
|
readonly seconds: number;
|
|
readonly milliseconds: number;
|
|
readonly microseconds: number;
|
|
readonly nanoseconds: number;
|
|
readonly sign: number;
|
|
readonly blank: boolean;
|
|
with(durationLike: PartialTemporalLike<DurationLikeObject>): Duration;
|
|
negated(): Duration;
|
|
abs(): Duration;
|
|
add(other: DurationLike): Duration;
|
|
subtract(other: DurationLike): Duration;
|
|
round(roundTo: PluralizeUnit<"day" | TimeUnit>): Duration;
|
|
round(roundTo: DurationRoundingOptions): Duration;
|
|
total(totalOf: PluralizeUnit<"day" | TimeUnit>): number;
|
|
total(totalOf: DurationTotalOptions): number;
|
|
toString(options?: DurationToStringOptions): string;
|
|
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DurationFormatOptions): string;
|
|
toJSON(): string;
|
|
valueOf(): never;
|
|
readonly [Symbol.toStringTag]: "Temporal.Duration";
|
|
}
|
|
|
|
interface DurationConstructor {
|
|
new (years?: number, months?: number, weeks?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, microseconds?: number, nanoseconds?: number): Duration;
|
|
readonly prototype: Duration;
|
|
from(item: DurationLike): Duration;
|
|
compare(one: DurationLike, two: DurationLike, options?: DurationRelativeToOptions): number;
|
|
}
|
|
var Duration: DurationConstructor;
|
|
|
|
interface InstantToStringOptions extends PlainTimeToStringOptions {
|
|
timeZone?: TimeZoneLike | undefined;
|
|
}
|
|
|
|
interface Instant {
|
|
readonly epochMilliseconds: number;
|
|
readonly epochNanoseconds: bigint;
|
|
add(duration: DurationLike): Instant;
|
|
subtract(duration: DurationLike): Instant;
|
|
until(other: InstantLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
|
|
since(other: InstantLike, options?: RoundingOptionsWithLargestUnit<TimeUnit>): Duration;
|
|
round(roundTo: PluralizeUnit<TimeUnit>): Instant;
|
|
round(roundTo: RoundingOptions<TimeUnit>): Instant;
|
|
equals(other: InstantLike): boolean;
|
|
toString(options?: InstantToStringOptions): string;
|
|
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
|
toJSON(): string;
|
|
valueOf(): never;
|
|
toZonedDateTimeISO(timeZone: TimeZoneLike): ZonedDateTime;
|
|
readonly [Symbol.toStringTag]: "Temporal.Instant";
|
|
}
|
|
|
|
interface InstantConstructor {
|
|
new (epochNanoseconds: bigint): Instant;
|
|
readonly prototype: Instant;
|
|
from(item: InstantLike): Instant;
|
|
fromEpochMilliseconds(epochMilliseconds: number): Instant;
|
|
fromEpochNanoseconds(epochNanoseconds: bigint): Instant;
|
|
compare(one: InstantLike, two: InstantLike): number;
|
|
}
|
|
var Instant: InstantConstructor;
|
|
|
|
interface PlainYearMonthToPlainDateOptions {
|
|
day: number;
|
|
}
|
|
|
|
interface PlainYearMonth {
|
|
readonly calendarId: string;
|
|
readonly era: string | undefined;
|
|
readonly eraYear: number | undefined;
|
|
readonly year: number;
|
|
readonly month: number;
|
|
readonly monthCode: string;
|
|
readonly daysInYear: number;
|
|
readonly daysInMonth: number;
|
|
readonly monthsInYear: number;
|
|
readonly inLeapYear: boolean;
|
|
with(yearMonthLike: PartialTemporalLike<YearMonthLikeObject>, options?: OverflowOptions): PlainYearMonth;
|
|
add(duration: DurationLike, options?: OverflowOptions): PlainYearMonth;
|
|
subtract(duration: DurationLike, options?: OverflowOptions): PlainYearMonth;
|
|
until(other: PlainYearMonthLike, options?: RoundingOptionsWithLargestUnit<"year" | "month">): Duration;
|
|
since(other: PlainYearMonthLike, options?: RoundingOptionsWithLargestUnit<"year" | "month">): Duration;
|
|
equals(other: PlainYearMonthLike): boolean;
|
|
toString(options?: PlainDateToStringOptions): string;
|
|
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
|
toJSON(): string;
|
|
valueOf(): never;
|
|
toPlainDate(item: PlainYearMonthToPlainDateOptions): PlainDate;
|
|
readonly [Symbol.toStringTag]: "Temporal.PlainYearMonth";
|
|
}
|
|
|
|
interface PlainYearMonthConstructor {
|
|
new (isoYear: number, isoMonth: number, calendar?: string, referenceISODay?: number): PlainYearMonth;
|
|
readonly prototype: PlainYearMonth;
|
|
from(item: PlainYearMonthLike, options?: OverflowOptions): PlainYearMonth;
|
|
compare(one: PlainYearMonthLike, two: PlainYearMonthLike): number;
|
|
}
|
|
var PlainYearMonth: PlainYearMonthConstructor;
|
|
|
|
interface PlainMonthDayToPlainDateOptions {
|
|
era?: string | undefined;
|
|
eraYear?: number | undefined;
|
|
year?: number | undefined;
|
|
}
|
|
|
|
interface PlainMonthDay {
|
|
readonly calendarId: string;
|
|
readonly monthCode: string;
|
|
readonly day: number;
|
|
with(monthDayLike: PartialTemporalLike<DateLikeObject>, options?: OverflowOptions): PlainMonthDay;
|
|
equals(other: PlainMonthDayLike): boolean;
|
|
toString(options?: PlainDateToStringOptions): string;
|
|
toLocaleString(locales?: Intl.LocalesArgument, options?: Intl.DateTimeFormatOptions): string;
|
|
toJSON(): string;
|
|
valueOf(): never;
|
|
toPlainDate(item: PlainMonthDayToPlainDateOptions): PlainDate;
|
|
readonly [Symbol.toStringTag]: "Temporal.PlainMonthDay";
|
|
}
|
|
|
|
interface PlainMonthDayConstructor {
|
|
new (isoMonth: number, isoDay: number, calendar?: string, referenceISOYear?: number): PlainMonthDay;
|
|
readonly prototype: PlainMonthDay;
|
|
from(item: PlainMonthDayLike, options?: OverflowOptions): PlainMonthDay;
|
|
}
|
|
var PlainMonthDay: PlainMonthDayConstructor;
|
|
}
|