type RoundingMode = 'ceil' | 'floor' | 'expand' | 'trunc' | 'halfCeil' | 'halfFloor' | 'halfExpand' | 'halfTrunc' | 'halfEven';

type PlainTimeLike = PlainTime | ZonedDateTime | Partial<TimeComponents> | string;
interface PlainTimeDeltaParameters {
    largestUnit?: 'auto' | 'hour' | 'minute' | 'second' | 'millisecond';
    smallestUnit?: 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
interface PlainTimeRoundParameters {
    smallestUnit: 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
interface PlainTimeToStringParameters {
    smallestUnit?: 'hour' | 'minute' | 'second' | 'millisecond';
    roundingMode?: RoundingMode;
    fractionalSecondDigits?: 'auto' | 0 | 1 | 2 | 3;
}
declare class PlainTime {
    readonly hour: number;
    readonly minute: number;
    readonly second: number;
    readonly millisecond: number;
    constructor(isoHour?: number, isoMinute?: number, isoSecond?: number, isoMillisecond?: number);
    toLocaleString(locales?: string | string[], options?: Intl.DateTimeFormatOptions): string;
    toString(options?: PlainTimeToStringParameters): string;
    toJSON(): string;
    add(durationLike: DurationLike): PlainTime;
    subtract(durationLike: DurationLike): PlainTime;
    with(timeComponents: Partial<TimeComponents>, options?: {
        overflow?: 'reject' | 'constrain';
    }): PlainTime;
    until(other: PlainTimeLike, options?: PlainTimeDeltaParameters): Duration;
    since(other: PlainTimeLike, options?: PlainTimeDeltaParameters): Duration;
    round(options: PlainTimeRoundParameters | PlainTimeRoundParameters['smallestUnit']): PlainTime;
    equals(other: PlainTimeLike): boolean;
    valueOf(): void;
    static from(item: PlainTimeLike, options?: {
        overflow?: 'reject' | 'constrain';
    }): PlainTime;
    static compare(one: PlainTimeLike, two: PlainTimeLike): number;
}

interface TimeZone {
    id: string;
    getOffsetMillisecondsFor(instant: number): number;
}
declare class DateTimeFormatTimeZone implements TimeZone {
    id: string;
    dateFormat: Intl.DateTimeFormat;
    constructor(id: string);
    getOffsetMillisecondsFor(milliseconds: number): number;
    static from(name: string): TimeZone;
}

type PlainDateTimeLike = ZonedDateTime | PlainDateTime | PlainDateTimeComponents | string;
interface PlainDateTimeComponents {
    year: number;
    month: number;
    day: number;
    hour?: number;
    minute?: number;
    second?: number;
    millisecond?: number;
}
interface PlainDateTimeToStringParameters {
    calendarName?: 'auto' | 'always' | 'never';
    smallestUnit?: 'minute' | 'second' | 'millisecond';
    roundingMode?: RoundingMode;
    fractionalSecondDigits?: 'auto' | 0 | 1 | 2 | 3;
}
interface PlainDateTimeRoundParameters {
    smallestUnit: 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
interface PlainDateTimeDeltaParameters {
    largestUnit?: 'auto' | 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    smallestUnit?: 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
declare class PlainDateTime {
    private raw;
    private calendar;
    constructor(isoYear: number, isoMonth: number, isoDay: number, isoHour?: number, isoMinute?: number, isoSecond?: number, isoMillisecond?: number, calendar?: string);
    get hour(): number;
    get minute(): number;
    get second(): number;
    get millisecond(): number;
    get day(): number;
    get month(): number;
    get year(): number;
    getCalendar(): Calendar;
    get calendarId(): string;
    get monthsInYear(): number;
    get inLeapYear(): boolean;
    get weekOfYear(): number;
    get yearOfWeek(): number;
    get dayOfYear(): number;
    get daysInYear(): number;
    get daysInMonth(): number;
    get daysInWeek(): number;
    get dayOfWeek(): number;
    equals(other: PlainDateTimeLike): boolean;
    valueOf(): void;
    round(options: PlainDateTimeRoundParameters['smallestUnit'] | PlainDateTimeRoundParameters): PlainDateTime;
    add(durationLike: DurationLike, options?: {
        overflow?: 'reject' | 'constrain';
    }): PlainDateTime;
    subtract(durationLike: DurationLike, options?: {
        overflow?: 'reject' | 'constrain';
    }): PlainDateTime;
    toPlainDate(): PlainDate;
    toPlainTime(): PlainTime;
    toZonedDateTime(timeZone: TimeZone | string, options?: ZonedDateTimeFromOptions): ZonedDateTime;
    toString(options?: PlainDateTimeToStringParameters): string;
    toJSON(): string;
    with(dateComponents: Partial<ZonedDateTimeComponents>, options?: {
        overflow?: 'reject' | 'constrain';
    }): PlainDateTime;
    withPlainTime(plainTimeLike: PlainTimeLike): PlainDateTime;
    withPlainDate(plainDateLike: PlainDateLike): PlainDateTime;
    withCalendar(calendar: string): PlainDateTime;
    until(otherLike: PlainDateTimeLike, options: PlainDateTimeDeltaParameters): Duration;
    since(other: PlainDateTimeLike, options: PlainDateTimeDeltaParameters): Duration;
    static from(item: PlainDateTimeLike, options?: {
        overflow?: 'reject' | 'constrain';
    }): PlainDateTime;
    static compare(one: PlainDateTimeLike, two: PlainDateTimeLike): number;
}

type PlainDateLike = PlainDate | (PlainDateComponents & {
    calendar?: string;
}) | string | ZonedDateTime | PlainDateTime;
interface PlainDateComponents {
    year: number;
    month: number;
    day: number;
}
interface PlainDateDeltaParameters {
    largestUnit?: 'auto' | 'year' | 'month' | 'week' | 'day';
    smallestUnit?: 'year' | 'month' | 'day';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
declare class PlainDate {
    private calendar;
    readonly year: number;
    readonly month: number;
    readonly day: number;
    constructor(isoYear: number, isoMonth: number, isoDay: number, calendar?: string);
    getCalendar(): Calendar;
    get calendarId(): string;
    get monthsInYear(): number;
    get inLeapYear(): boolean;
    get weekOfYear(): number;
    get yearOfWeek(): number;
    get dayOfYear(): number;
    get daysInYear(): number;
    get daysInMonth(): number;
    get daysInWeek(): number;
    get dayOfWeek(): number;
    with(dateLike: Partial<PlainDateComponents>, options?: {
        overflow: 'reject' | 'constrain';
    }): PlainDate;
    add(durationLike: DurationLike, options?: {
        overflow: 'reject' | 'constrain';
    }): PlainDate;
    subtract(durationLike: DurationLike, options?: {
        overflow: 'reject' | 'constrain';
    }): PlainDate;
    until(other: PlainDateLike, options: PlainDateDeltaParameters): Duration;
    since(other: PlainDateLike, options: PlainDateDeltaParameters): Duration;
    equals(other: PlainDateLike): boolean;
    toJSON(): string;
    toString(options?: {
        calendarName?: 'auto' | 'always' | 'never';
    }): string;
    toLocaleString(locales: string | string[], options?: Intl.DateTimeFormatOptions): string;
    toPlainDateTime(timeLike: PlainTimeLike): PlainDateTime;
    valueOf(): void;
    static from(item: PlainDateLike, options?: {
        overflow?: 'reject' | 'constrain';
    }): PlainDate;
    static compare(one: PlainDateLike, two: PlainDateLike): number;
}

declare class Calendar {
    get id(): string;
    toString(): string;
    toJSON(): string;
    monthsInYear(_date: ZonedDateTime | PlainDate | PlainDateTime): number;
    daysInWeek(_date: ZonedDateTime | PlainDate | PlainDateTime): number;
    weekOfYear(date: ZonedDateTime | PlainDate | PlainDateTime): number;
    yearOfWeek(date: ZonedDateTime | PlainDate | PlainDateTime): number;
    daysInMonth(date: ZonedDateTime | PlainDate | PlainDateTime): number;
    inLeapYear(date: ZonedDateTime | PlainDate | PlainDateTime): boolean;
    daysInYear(date: ZonedDateTime | PlainDate | PlainDateTime): number;
    dayOfWeek(date: ZonedDateTime | PlainDate | PlainDateTime): number;
    dayOfYear(date: ZonedDateTime | PlainDate | PlainDateTime): number;
    dateUntil(one: PlainDate, two: PlainDate, options?: {
        largestUnit: 'auto' | 'year' | 'month' | 'week' | 'day';
    }): Duration;
    dateAdd(date: PlainDate, durationLike: Duration | string, options?: {
        overflow?: 'reject' | 'constrain';
    }): PlainDate;
    static from(type: string): Calendar;
}

interface InstantRoundParameters {
    smallestUnit: 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
interface InstantDeltaParameters {
    largestUnit?: 'auto' | 'hour' | 'minute' | 'second' | 'millisecond';
    smallestUnit?: 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
type InstantLike = string | Instant;
declare class Instant {
    private raw;
    constructor(epochMilisecond: number);
    get epochMilliseconds(): number;
    add(durationLike: DurationLike): Instant;
    subtract(durationLike: DurationLike): Instant;
    until(other: InstantLike, options?: InstantDeltaParameters): Duration;
    since(other: InstantLike, options?: InstantDeltaParameters): Duration;
    toZonedDateTimeISO(timeZone: string | TimeZone): ZonedDateTime;
    equals(other: InstantLike): boolean;
    toJSON(): string;
    toString(): string;
    toLocaleString(): void;
    valueOf(): void;
    round(options: InstantRoundParameters['smallestUnit'] | InstantRoundParameters): Instant;
    static from(instantLike: InstantLike): Instant;
    static fromEpochMilliseconds(epochMilisecond: number): Instant;
    static compare(one: InstantLike, two: InstantLike): number;
}

interface ZonedDateTimeComponents {
    year: number;
    month: number;
    week: number;
    day: number;
    hour: number;
    minute: number;
    second: number;
    millisecond: number;
}
interface ZonedDateTimeFromOptions {
    disambiguation?: 'compatible' | 'earlier' | 'later';
}
type ZonedDateTimeLike = ZonedDateTime | DateTimeLike | string;
interface DateTimeLike {
    year: number;
    month: number;
    day: number;
    hour?: number;
    minute?: number;
    second?: number;
    millisecond?: number;
    timeZone: string | TimeZone;
}
interface ZonedDateAddParameters {
    overflow?: 'reject' | 'constrain';
}
interface ZonedDateTimeRoundParameters {
    smallestUnit: 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
interface ZonedDateTimeDeltaParameters {
    largestUnit?: 'auto' | 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    smallestUnit?: 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
}
interface ZonedDateTimeToStringParameters {
    offset?: 'auto' | 'never';
    timeZoneName?: 'auto' | 'never' | 'critical';
    calendarName?: 'auto' | 'always' | 'never' | 'critical';
    fractionalSecondDigits?: 'auto' | 1 | 2 | 3;
    smallestUnit?: 'minute' | 'second' | 'millisecond';
    roundingMode?: RoundingMode;
}
declare class ZonedDateTime {
    private raw;
    private timeZone;
    private calendar;
    constructor(epochMillisecond: number, timeZoneLike: string | TimeZone);
    get hour(): number;
    get minute(): number;
    get second(): number;
    get millisecond(): number;
    get day(): number;
    get month(): number;
    get year(): number;
    get epochSeconds(): number;
    get epochMilliseconds(): number;
    get offsetMilliseconds(): number;
    get offset(): string;
    get inLeapYear(): boolean;
    get timeZoneId(): string;
    getCalendar(): Calendar;
    get calendarId(): string;
    get daysInWeek(): number;
    get daysInMonth(): number;
    get monthsInYear(): number;
    get daysInYear(): number;
    get weekOfYear(): number;
    get yearOfWeek(): number;
    get hoursInDay(): number;
    get dayOfYear(): number;
    get dayOfWeek(): number;
    getTimeZone(): TimeZone;
    add(durationLike: DurationLike, options?: ZonedDateAddParameters): ZonedDateTime;
    subtract(duration: DurationLike, options?: ZonedDateAddParameters): ZonedDateTime;
    startOfDay(): ZonedDateTime;
    round(options: ZonedDateTimeRoundParameters['smallestUnit'] | ZonedDateTimeRoundParameters): ZonedDateTime;
    until(zonedDateTimeLike: ZonedDateTimeLike, options?: ZonedDateTimeDeltaParameters): Duration;
    since(other: ZonedDateTimeLike, options?: ZonedDateTimeDeltaParameters): Duration;
    equals(otherLike: ZonedDateTimeLike): boolean;
    with(zonedDateTimeLike: Partial<ZonedDateTimeComponents>): ZonedDateTime;
    toJSON(): string;
    toString(options?: ZonedDateTimeToStringParameters): string;
    toLocaleString(locales: string | string[], options?: Intl.DateTimeFormatOptions): string;
    toInstant(): Instant;
    toPlainDate(): PlainDate;
    toPlainTime(): PlainTime;
    toPlainDateTime(): PlainDateTime;
    withTimeZone(timeZone: string | TimeZone): ZonedDateTime;
    valueOf(): void;
    private adjustOffset;
    static from(dateComponents: ZonedDateTimeLike, options?: ZonedDateTimeFromOptions): ZonedDateTime;
    static compare(one: ZonedDateTimeLike, two: ZonedDateTimeLike): number;
}

interface TimeComponents {
    hour: number;
    minute: number;
    second: number;
    millisecond: number;
}
type RelativeToLike = PlainDate | ZonedDateTime | ZonedDateTimeLike | PlainDateLike;

interface DeltaRoundParameters {
    largestUnit?: 'auto' | 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    smallestUnit?: 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    roundingIncrement?: number;
    roundingMode?: RoundingMode;
    relativeTo?: RelativeToLike;
}
interface DurationToStringParameters {
    fractionalSecondDigits?: 'auto' | 1 | 2 | 3;
    smallestUnit?: 'minute' | 'second' | 'millisecond';
    roundingMode?: RoundingMode;
}
interface DurationTotalParameters {
    unit: 'year' | 'month' | 'week' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond';
    relativeTo?: RelativeToLike;
}
interface DurationCompareParameters {
    relativeTo?: RelativeToLike;
}
interface DateComponents {
    years: number;
    months: number;
    weeks: number;
    days: number;
    hours: number;
    minutes: number;
    seconds: number;
    milliseconds: number;
}
type DurationLike = Duration | string | Partial<DateComponents>;
declare class 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;
    constructor(years?: number, months?: number, weeks?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number);
    get sign(): number;
    get blank(): boolean;
    negated(): Duration;
    abs(): Duration;
    add(durationLike: DurationLike): Duration;
    with(durationLike: Partial<DateComponents>): Duration;
    round(roundTo: Exclude<DeltaRoundParameters['smallestUnit'], undefined> | DeltaRoundParameters): Duration;
    subtract(durationLike: DurationLike): Duration;
    toString(options?: DurationToStringParameters): string;
    toJSON(): string;
    total(totalOf: DurationTotalParameters['unit'] | DurationTotalParameters): number;
    valueOf(): void;
    static compare(oneLike: DurationLike, twoLike: DurationLike, options?: DurationCompareParameters): number;
    static from(other: DurationLike): Duration;
}

declare const Now: {
    instant(): Instant;
    timeZoneId(): string;
    zonedDateTimeISO(timeZoneLike?: string | TimeZone): ZonedDateTime;
    plainDateISO(): PlainDate;
    plainDateTimeISO(): PlainDateTime;
    plainTimeISO(): PlainTime;
};

export { Calendar, DateTimeFormatTimeZone, type DateTimeLike, Duration, Instant, Now, PlainDate, PlainDateTime, PlainTime, type TimeZone, ZonedDateTime };