// original:
// - https://github.com/microsoft/TypeScript/blob/c9e7428bb76f0543a3555d0af87777e7db3a41e6/src/lib/esnext.temporal.d.ts
// - https://github.com/microsoft/TypeScript/blob/c9e7428bb76f0543a3555d0af87777e7db3a41e6/src/lib/esnext.intl.d.ts
/*! Copyright (c) Microsoft Corporation */
/*! SPDX-License-Identifier: Apache-2.0 */

export {};

declare global {
	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;
	}

	namespace Intl {
		type FormattableTemporalObject =
			| Temporal.PlainDate
			| Temporal.PlainYearMonth
			| Temporal.PlainMonthDay
			| Temporal.PlainTime
			| Temporal.PlainDateTime
			| Temporal.Instant;

		interface DateTimeFormat {
			format(date?: FormattableTemporalObject | Date | number): string;
			formatToParts(date?: FormattableTemporalObject | Date | number): DateTimeFormatPart[];
			formatRange(
				startDate: FormattableTemporalObject | Date | number,
				endDate: FormattableTemporalObject | Date | number,
			): string;
			formatRangeToParts(
				startDate: FormattableTemporalObject | Date | number,
				endDate: FormattableTemporalObject | Date | number,
			): DateTimeRangeFormatPart[];
		}
	}

	interface Date {
		toTemporalInstant(): Temporal.Instant;
	}
}