@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/time/chrono/Era/index.d.ts

@@ -0,0 +1,202 @@
+import type { TemporalField } from "../../temporal/TemporalField";
+
+import type { ValueRange } from "../../temporal/ValueRange";
+
+import type { TemporalQuery } from "../../temporal/TemporalQuery";
+
+import type { Temporal } from "../../temporal/Temporal";
+import type { TextStyle } from "../../format/TextStyle";
+import type { Locale } from "../../../util/Locale";
+import type { String } from "../../../lang/String";
+import type { TemporalAccessor } from "../../temporal/TemporalAccessor";
+import type { TemporalAdjuster } from "../../temporal/TemporalAdjuster";
+
+/**
+ * An era of the time-line.
+ *  <p>
+ *  Most calendar systems have a single epoch dividing the time-line into two eras.
+ *  However, some calendar systems, have multiple eras, such as one for the reign
+ *  of each leader.
+ *  In all cases, the era is conceptually the largest division of the time-line.
+ *  Each chronology defines the Era's that are known Eras and a
+ *  {@link Chronology#eras Chronology.eras} to get the valid eras.
+ *  <p>
+ *  For example, the Thai Buddhist calendar system divides time into two eras,
+ *  before and after a single date. By contrast, the Japanese calendar system
+ *  has one era for the reign of each Emperor.
+ *  <p>
+ *  Instances of {@code Era} may be compared using the {@code ==} operator.
+ * @implSpec This interface must be implemented with care to ensure other classes operate correctly.&#xA; All implementations must be singletons - final, immutable and thread-safe.&#xA; It is recommended to use an enum whenever possible.
+ * @since 1.8
+ */
+export type Era = TemporalAccessor &
+  TemporalAdjuster & {
+    /**
+     * Gets the numeric value associated with the era as defined by the chronology.
+     *  Each chronology defines the predefined Eras and methods to list the Eras
+     *  of the chronology.
+     *  <p>
+     *  All fields, including eras, have an associated numeric value.
+     *  The meaning of the numeric value for era is determined by the chronology
+     *  according to these principles:
+     *  <ul>
+     *  <li>The era in use at the epoch 1970-01-01 (ISO) has the value 1.
+     *  <li>Later eras have sequentially higher values.
+     *  <li>Earlier eras have sequentially lower values, which may be negative.
+     *  </ul>
+     * @return the numeric era value
+     */
+    getValue(): number;
+
+    /**
+     * Checks if the specified field is supported.
+     *  <p>
+     *  This checks if this era can be queried for the specified field.
+     *  If false, then calling the {@link #range(TemporalField) range} and
+     *  {@link #get(TemporalField) get} methods will throw an exception.
+     *  <p>
+     *  If the field is a {@link ChronoField} then the query is implemented here.
+     *  The {@code ERA} field returns true.
+     *  All other {@code ChronoField} instances will return false.
+     *  <p>
+     *  If the field is not a {@code ChronoField}, then the result of this method
+     *  is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)}
+     *  passing {@code this} as the argument.
+     *  Whether the field is supported is determined by the field.
+     * @param field the field to check, null returns false
+     * @return true if the field is supported on this era, false if not
+     */
+    isSupported(field: TemporalField): boolean;
+
+    /**
+     * Gets the range of valid values for the specified field.
+     *  <p>
+     *  The range object expresses the minimum and maximum valid values for a field.
+     *  This era is used to enhance the accuracy of the returned range.
+     *  If it is not possible to return the range, because the field is not supported
+     *  or for some other reason, an exception is thrown.
+     *  <p>
+     *  If the field is a {@link ChronoField} then the query is implemented here.
+     *  The {@code ERA} field returns the range.
+     *  All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
+     *  <p>
+     *  If the field is not a {@code ChronoField}, then the result of this method
+     *  is obtained by invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)}
+     *  passing {@code this} as the argument.
+     *  Whether the range can be obtained is determined by the field.
+     *  <p>
+     *  The default implementation must return a range for {@code ERA} from
+     *  zero to one, suitable for two era calendar systems such as ISO.
+     * @param field the field to query the range for, not null
+     * @return the range of valid values for the field, not null
+     * @throws DateTimeException if the range for the field cannot be obtained
+     * @throws UnsupportedTemporalTypeException if the unit is not supported
+     */
+    range(field: TemporalField): ValueRange;
+
+    /**
+     * Gets the value of the specified field from this era as an {@code int}.
+     *  <p>
+     *  This queries this era for the value of the specified field.
+     *  The returned value will always be within the valid range of values for the field.
+     *  If it is not possible to return the value, because the field is not supported
+     *  or for some other reason, an exception is thrown.
+     *  <p>
+     *  If the field is a {@link ChronoField} then the query is implemented here.
+     *  The {@code ERA} field returns the value of the era.
+     *  All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
+     *  <p>
+     *  If the field is not a {@code ChronoField}, then the result of this method
+     *  is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}
+     *  passing {@code this} as the argument. Whether the value can be obtained,
+     *  and what the value represents, is determined by the field.
+     * @param field the field to get, not null
+     * @return the value for the field
+     * @throws DateTimeException if a value for the field cannot be obtained or&#xA; the value is outside the range of valid values for the field
+     * @throws UnsupportedTemporalTypeException if the field is not supported or&#xA; the range of values exceeds an {@code int}
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    get(field: TemporalField): number;
+
+    /**
+     * Gets the value of the specified field from this era as a {@code long}.
+     *  <p>
+     *  This queries this era for the value of the specified field.
+     *  If it is not possible to return the value, because the field is not supported
+     *  or for some other reason, an exception is thrown.
+     *  <p>
+     *  If the field is a {@link ChronoField} then the query is implemented here.
+     *  The {@code ERA} field returns the value of the era.
+     *  All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}.
+     *  <p>
+     *  If the field is not a {@code ChronoField}, then the result of this method
+     *  is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)}
+     *  passing {@code this} as the argument. Whether the value can be obtained,
+     *  and what the value represents, is determined by the field.
+     * @param field the field to get, not null
+     * @return the value for the field
+     * @throws DateTimeException if a value for the field cannot be obtained
+     * @throws UnsupportedTemporalTypeException if the field is not supported
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    getLong(field: TemporalField): number;
+
+    /**
+     * Queries this era using the specified query.
+     *  <p>
+     *  This queries this era using the specified query strategy object.
+     *  The {@code TemporalQuery} object defines the logic to be used to
+     *  obtain the result. Read the documentation of the query to understand
+     *  what the result of this method will be.
+     *  <p>
+     *  The result of this method is obtained by invoking the
+     *  {@link TemporalQuery#queryFrom(TemporalAccessor)} method on the
+     *  specified query passing {@code this} as the argument.
+     * @param <R> the type of the result
+     * @param query the query to invoke, not null
+     * @return the query result, null may be returned (defined by the query)
+     * @throws DateTimeException if unable to query (defined by the query)
+     * @throws ArithmeticException if numeric overflow occurs (defined by the query)
+     */
+    query(query: TemporalQuery): unknown;
+
+    /**
+     * Adjusts the specified temporal object to have the same era as this object.
+     *  <p>
+     *  This returns a temporal object of the same observable type as the input
+     *  with the era changed to be the same as this.
+     *  <p>
+     *  The adjustment is equivalent to using {@link Temporal#with(TemporalField, long)}
+     *  passing {@link ChronoField#ERA} as the field.
+     *  <p>
+     *  In most cases, it is clearer to reverse the calling pattern by using
+     *  {@link Temporal#with(TemporalAdjuster)}:
+     *  <pre>
+     *    // these two lines are equivalent, but the second approach is recommended
+     *    temporal = thisEra.adjustInto(temporal);
+     *    temporal = temporal.with(thisEra);
+     *  </pre>
+     *  <p>
+     *  This instance is immutable and unaffected by this method call.
+     * @param temporal the target object to be adjusted, not null
+     * @return the adjusted object, not null
+     * @throws DateTimeException if unable to make the adjustment
+     * @throws ArithmeticException if numeric overflow occurs
+     */
+    adjustInto(temporal: Temporal): Temporal;
+
+    /**
+     * Gets the textual representation of this era.
+     *  <p>
+     *  This returns the textual name used to identify the era,
+     *  suitable for presentation to the user.
+     *  The parameters control the style of the returned text and the locale.
+     *  <p>
+     *  If no textual mapping is found then the {@link #getValue() numeric value} is returned.
+     * @apiNote This default implementation is suitable for most implementations.
+     * @param style the style of the text required, not null
+     * @param locale the locale to use, not null
+     * @return the text value of the era, not null
+     */
+    getDisplayName(style: TextStyle, locale: Locale): string;
+  };

package/types/java/time/chrono/Era/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getValue: function getValue() {},
+  isSupported: function isSupported() {},
+  range: function range() {},
+  get: function get() {},
+  getLong: function getLong() {},
+  query: function query() {},
+  adjustInto: function adjustInto() {},
+  getDisplayName: function getDisplayName() {}
+};
+exports["default"] = _default;

package/types/java/time/chrono/IsoChronology/index.d.ts

@@ -0,0 +1,345 @@
+import type { String } from "../../../lang/String";
+import type { Era } from "../Era";
+
+import type { LocalDate } from "../../LocalDate";
+
+import type { TemporalAccessor } from "../../temporal/TemporalAccessor";
+import type { LocalDateTime } from "../../LocalDateTime";
+import type { ZonedDateTime } from "../../ZonedDateTime";
+import type { Instant } from "../../Instant";
+import type { ZoneId } from "../../ZoneId";
+import type { Clock } from "../../Clock";
+
+import type { IsoEra } from "../IsoEra";
+import type { List } from "../../../util/List";
+import type { Map } from "../../../util/Map";
+import type { ResolverStyle } from "../../format/ResolverStyle";
+import type { ChronoField } from "../../temporal/ChronoField";
+import type { ValueRange } from "../../temporal/ValueRange";
+import type { Period } from "../../Period";
+import type { AbstractChronology } from "../AbstractChronology";
+import type { Serializable } from "../../../io/Serializable";
+
+/**
+ * The ISO calendar system.
+ *  <p>
+ *  This chronology defines the rules of the ISO calendar system.
+ *  This calendar system is based on the ISO-8601 standard, which is the
+ *  <i>de facto</i> world calendar.
+ *  <p>
+ *  The fields are defined as follows:
+ *  <ul>
+ *  <li>era - There are two eras, 'Current Era' (CE) and 'Before Current Era' (BCE).
+ *  <li>year-of-era - The year-of-era is the same as the proleptic-year for the current CE era.
+ *   For the BCE era before the ISO epoch the year increases from 1 upwards as time goes backwards.
+ *  <li>proleptic-year - The proleptic year is the same as the year-of-era for the
+ *   current era. For the previous era, years have zero, then negative values.
+ *  <li>month-of-year - There are 12 months in an ISO year, numbered from 1 to 12.
+ *  <li>day-of-month - There are between 28 and 31 days in each of the ISO month, numbered from 1 to 31.
+ *   Months 4, 6, 9 and 11 have 30 days, Months 1, 3, 5, 7, 8, 10 and 12 have 31 days.
+ *   Month 2 has 28 days, or 29 in a leap year.
+ *  <li>day-of-year - There are 365 days in a standard ISO year and 366 in a leap year.
+ *   The days are numbered from 1 to 365 or 1 to 366.
+ *  <li>leap-year - Leap years occur every 4 years, except where the year is divisble by 100 and not divisble by 400.
+ *  </ul>
+ * @implSpec This class is immutable and thread-safe.
+ * @since 1.8
+ */
+export type IsoChronology = AbstractChronology &
+  Serializable & {
+    /**
+     * Gets the ID of the chronology - 'ISO'.
+     *  <p>
+     *  The ID uniquely identifies the {@code Chronology}.
+     *  It can be used to lookup the {@code Chronology} using {@link Chronology#of(String)}.
+     * @return the chronology ID - 'ISO'
+     * @see #getCalendarType()
+     */
+    getId(): string;
+
+    /**
+     * Gets the calendar type of the underlying calendar system - 'iso8601'.
+     *  <p>
+     *  The calendar type is an identifier defined by the
+     *  <em>Unicode Locale Data Markup Language (LDML)</em> specification.
+     *  It can be used to lookup the {@code Chronology} using {@link Chronology#of(String)}.
+     *  It can also be used as part of a locale, accessible via
+     *  {@link Locale#getUnicodeLocaleType(String)} with the key 'ca'.
+     * @return the calendar system type - 'iso8601'
+     * @see #getId()
+     */
+    getCalendarType(): string;
+
+    /**
+     * Obtains an ISO local date from the era, year-of-era, month-of-year
+     *  and day-of-month fields.
+     * @param era the ISO era, not null
+     * @param yearOfEra the ISO year-of-era
+     * @param month the ISO month-of-year
+     * @param dayOfMonth the ISO day-of-month
+     * @return the ISO local date, not null
+     * @throws DateTimeException if unable to create the date
+     * @throws ClassCastException if the type of {@code era} is not {@code IsoEra}
+     */
+    date(
+      era: Era,
+      yearOfEra: number,
+      month: number,
+      dayOfMonth: number
+    ): LocalDate;
+
+    /**
+     * Obtains an ISO local date from the proleptic-year, month-of-year
+     *  and day-of-month fields.
+     *  <p>
+     *  This is equivalent to {@link LocalDate#of(int, int, int)}.
+     * @param prolepticYear the ISO proleptic-year
+     * @param month the ISO month-of-year
+     * @param dayOfMonth the ISO day-of-month
+     * @return the ISO local date, not null
+     * @throws DateTimeException if unable to create the date
+     */
+    date(prolepticYear: number, month: number, dayOfMonth: number): LocalDate;
+
+    /**
+     * Obtains an ISO local date from the era, year-of-era and day-of-year fields.
+     * @param era the ISO era, not null
+     * @param yearOfEra the ISO year-of-era
+     * @param dayOfYear the ISO day-of-year
+     * @return the ISO local date, not null
+     * @throws DateTimeException if unable to create the date
+     */
+    dateYearDay(era: Era, yearOfEra: number, dayOfYear: number): LocalDate;
+
+    /**
+     * Obtains an ISO local date from the proleptic-year and day-of-year fields.
+     *  <p>
+     *  This is equivalent to {@link LocalDate#ofYearDay(int, int)}.
+     * @param prolepticYear the ISO proleptic-year
+     * @param dayOfYear the ISO day-of-year
+     * @return the ISO local date, not null
+     * @throws DateTimeException if unable to create the date
+     */
+    dateYearDay(prolepticYear: number, dayOfYear: number): LocalDate;
+
+    /**
+     * Obtains an ISO local date from the epoch-day.
+     *  <p>
+     *  This is equivalent to {@link LocalDate#ofEpochDay(long)}.
+     * @param epochDay the epoch day
+     * @return the ISO local date, not null
+     * @throws DateTimeException if unable to create the date
+     */
+    dateEpochDay(epochDay: number): LocalDate;
+
+    /**
+     * Obtains an ISO local date from another date-time object.
+     *  <p>
+     *  This is equivalent to {@link LocalDate#from(TemporalAccessor)}.
+     * @param temporal the date-time object to convert, not null
+     * @return the ISO local date, not null
+     * @throws DateTimeException if unable to create the date
+     */
+    date(temporal: TemporalAccessor): LocalDate;
+
+    /**
+     * Obtains an ISO local date-time from another date-time object.
+     *  <p>
+     *  This is equivalent to {@link LocalDateTime#from(TemporalAccessor)}.
+     * @param temporal the date-time object to convert, not null
+     * @return the ISO local date-time, not null
+     * @throws DateTimeException if unable to create the date-time
+     */
+    localDateTime(temporal: TemporalAccessor): LocalDateTime;
+
+    /**
+     * Obtains an ISO zoned date-time from another date-time object.
+     *  <p>
+     *  This is equivalent to {@link ZonedDateTime#from(TemporalAccessor)}.
+     * @param temporal the date-time object to convert, not null
+     * @return the ISO zoned date-time, not null
+     * @throws DateTimeException if unable to create the date-time
+     */
+    zonedDateTime(temporal: TemporalAccessor): ZonedDateTime;
+
+    /**
+     * Obtains an ISO zoned date-time in this chronology from an {@code Instant}.
+     *  <p>
+     *  This is equivalent to {@link ZonedDateTime#ofInstant(Instant, ZoneId)}.
+     * @param instant the instant to create the date-time from, not null
+     * @param zone the time-zone, not null
+     * @return the zoned date-time, not null
+     * @throws DateTimeException if the result exceeds the supported range
+     */
+    zonedDateTime(instant: Instant, zone: ZoneId): ZonedDateTime;
+
+    /**
+     * Obtains the current ISO local date from the system clock in the default time-zone.
+     *  <p>
+     *  This will query the {@link Clock#systemDefaultZone() system clock} in the default
+     *  time-zone to obtain the current date.
+     *  <p>
+     *  Using this method will prevent the ability to use an alternate clock for testing
+     *  because the clock is hard-coded.
+     * @return the current ISO local date using the system clock and default time-zone, not null
+     * @throws DateTimeException if unable to create the date
+     */
+    dateNow(): LocalDate;
+
+    /**
+     * Obtains the current ISO local date from the system clock in the specified time-zone.
+     *  <p>
+     *  This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
+     *  Specifying the time-zone avoids dependence on the default time-zone.
+     *  <p>
+     *  Using this method will prevent the ability to use an alternate clock for testing
+     *  because the clock is hard-coded.
+     * @return the current ISO local date using the system clock, not null
+     * @throws DateTimeException if unable to create the date
+     */
+    dateNow(zone: ZoneId): LocalDate;
+
+    /**
+     * Obtains the current ISO local date from the specified clock.
+     *  <p>
+     *  This will query the specified clock to obtain the current date - today.
+     *  Using this method allows the use of an alternate clock for testing.
+     *  The alternate clock may be introduced using {@link Clock dependency injection}.
+     * @param clock the clock to use, not null
+     * @return the current ISO local date, not null
+     * @throws DateTimeException if unable to create the date
+     */
+    dateNow(clock: Clock): LocalDate;
+
+    /**
+     * 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.
+     * @param prolepticYear the ISO proleptic year to check
+     * @return true if the year is leap, false otherwise
+     */
+    isLeapYear(prolepticYear: number): boolean;
+
+    prolepticYear(era: Era, yearOfEra: number): number;
+
+    eraOf(eraValue: number): IsoEra;
+
+    eras(): List;
+
+    /**
+     * Resolves parsed {@code ChronoField} values into a date during parsing.
+     *  <p>
+     *  Most {@code TemporalField} implementations are resolved using the
+     *  resolve method on the field. By contrast, the {@code ChronoField} class
+     *  defines fields that only have meaning relative to the chronology.
+     *  As such, {@code ChronoField} date fields are resolved here in the
+     *  context of a specific chronology.
+     *  <p>
+     *  {@code ChronoField} instances on the ISO calendar system are resolved
+     *  as follows.
+     *  <ul>
+     *  <li>{@code EPOCH_DAY} - If present, this is converted to a {@code LocalDate}
+     *   and all other date fields are then cross-checked against the date.
+     *  <li>{@code PROLEPTIC_MONTH} - If present, then it is split into the
+     *   {@code YEAR} and {@code MONTH_OF_YEAR}. If the mode is strict or smart
+     *   then the field is validated.
+     *  <li>{@code YEAR_OF_ERA} and {@code ERA} - If both are present, then they
+     *   are combined to form a {@code YEAR}. In lenient mode, the {@code YEAR_OF_ERA}
+     *   range is not validated, in smart and strict mode it is. The {@code ERA} is
+     *   validated for range in all three modes. If only the {@code YEAR_OF_ERA} is
+     *   present, and the mode is smart or lenient, then the current era (CE/AD)
+     *   is assumed. In strict mode, no era is assumed and the {@code YEAR_OF_ERA} is
+     *   left untouched. If only the {@code ERA} is present, then it is left untouched.
+     *  <li>{@code YEAR}, {@code MONTH_OF_YEAR} and {@code DAY_OF_MONTH} -
+     *   If all three are present, then they are combined to form a {@code LocalDate}.
+     *   In all three modes, the {@code YEAR} is validated. If the mode is smart or strict,
+     *   then the month and day are validated, with the day validated from 1 to 31.
+     *   If the mode is lenient, then the date is combined in a manner equivalent to
+     *   creating a date on the first of January in the requested year, then adding
+     *   the difference in months, then the difference in days.
+     *   If the mode is smart, and the day-of-month is greater than the maximum for
+     *   the year-month, then the day-of-month is adjusted to the last day-of-month.
+     *   If the mode is strict, then the three fields must form a valid date.
+     *  <li>{@code YEAR} and {@code DAY_OF_YEAR} -
+     *   If both are present, then they are combined to form a {@code LocalDate}.
+     *   In all three modes, the {@code YEAR} is validated.
+     *   If the mode is lenient, then the date is combined in a manner equivalent to
+     *   creating a date on the first of January in the requested year, then adding
+     *   the difference in days.
+     *   If the mode is smart or strict, then the two fields must form a valid date.
+     *  <li>{@code YEAR}, {@code MONTH_OF_YEAR}, {@code ALIGNED_WEEK_OF_MONTH} and
+     *   {@code ALIGNED_DAY_OF_WEEK_IN_MONTH} -
+     *   If all four are present, then they are combined to form a {@code LocalDate}.
+     *   In all three modes, the {@code YEAR} is validated.
+     *   If the mode is lenient, then the date is combined in a manner equivalent to
+     *   creating a date on the first of January in the requested year, then adding
+     *   the difference in months, then the difference in weeks, then in days.
+     *   If the mode is smart or strict, then the all four fields are validated to
+     *   their outer ranges. The date is then combined in a manner equivalent to
+     *   creating a date on the first day of the requested year and month, then adding
+     *   the amount in weeks and days to reach their values. If the mode is strict,
+     *   the date is additionally validated to check that the day and week adjustment
+     *   did not change the month.
+     *  <li>{@code YEAR}, {@code MONTH_OF_YEAR}, {@code ALIGNED_WEEK_OF_MONTH} and
+     *   {@code DAY_OF_WEEK} - If all four are present, then they are combined to
+     *   form a {@code LocalDate}. The approach is the same as described above for
+     *   years, months and weeks in {@code ALIGNED_DAY_OF_WEEK_IN_MONTH}.
+     *   The day-of-week is adjusted as the next or same matching day-of-week once
+     *   the years, months and weeks have been handled.
+     *  <li>{@code YEAR}, {@code ALIGNED_WEEK_OF_YEAR} and {@code ALIGNED_DAY_OF_WEEK_IN_YEAR} -
+     *   If all three are present, then they are combined to form a {@code LocalDate}.
+     *   In all three modes, the {@code YEAR} is validated.
+     *   If the mode is lenient, then the date is combined in a manner equivalent to
+     *   creating a date on the first of January in the requested year, then adding
+     *   the difference in weeks, then in days.
+     *   If the mode is smart or strict, then the all three fields are validated to
+     *   their outer ranges. The date is then combined in a manner equivalent to
+     *   creating a date on the first day of the requested year, then adding
+     *   the amount in weeks and days to reach their values. If the mode is strict,
+     *   the date is additionally validated to check that the day and week adjustment
+     *   did not change the year.
+     *  <li>{@code YEAR}, {@code ALIGNED_WEEK_OF_YEAR} and {@code DAY_OF_WEEK} -
+     *   If all three are present, then they are combined to form a {@code LocalDate}.
+     *   The approach is the same as described above for years and weeks in
+     *   {@code ALIGNED_DAY_OF_WEEK_IN_YEAR}. The day-of-week is adjusted as the
+     *   next or same matching day-of-week once the years and weeks have been handled.
+     *  </ul>
+     * @param fieldValues the map of fields to values, which can be updated, not null
+     * @param resolverStyle the requested type of resolve, not null
+     * @return the resolved date, null if insufficient information to create a date
+     * @throws DateTimeException if the date cannot be resolved, typically&#xA; because of a conflict in the input data
+     */
+    resolveDate(fieldValues: Map | {}, resolverStyle: ResolverStyle): LocalDate;
+
+    range(field: ChronoField): ValueRange;
+
+    /**
+     * Obtains a period for this chronology based on years, months and days.
+     *  <p>
+     *  This returns a period tied to the ISO chronology using the specified
+     *  years, months and days. See {@link Period} for further details.
+     * @param years the number of years, may be negative
+     * @param months the number of years, may be negative
+     * @param days the number of years, may be negative
+     * @return the period in terms of this chronology, not null
+     * @return the ISO period, not null
+     */
+    period(years: number, months: number, days: number): Period;
+
+    /**
+ * Singleton instance of the ISO chronology.
+  
+    */
+    INSTANCE: IsoChronology;
+  };

package/types/java/time/chrono/IsoChronology/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  getId: function getId() {},
+  getCalendarType: function getCalendarType() {},
+  date: function date() {},
+  dateYearDay: function dateYearDay() {},
+  dateEpochDay: function dateEpochDay() {},
+  localDateTime: function localDateTime() {},
+  zonedDateTime: function zonedDateTime() {},
+  dateNow: function dateNow() {},
+  isLeapYear: function isLeapYear() {},
+  prolepticYear: function prolepticYear() {},
+  eraOf: function eraOf() {},
+  eras: function eras() {},
+  resolveDate: function resolveDate() {},
+  range: function range() {},
+  period: function period() {}
+};
+exports["default"] = _default;

package/types/java/time/chrono/IsoEra/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * An era in the ISO calendar system.
+ *  <p>
+ *  The ISO-8601 standard does not define eras.
+ *  A definition has therefore been created with two eras - 'Current era' (CE) for
+ *  years on or after 0001-01-01 (ISO), and 'Before current era' (BCE) for years before that.
+ *
+ *  <table summary="ISO years and eras" cellpadding="2" cellspacing="3" border="0" >
+ *  <thead>
+ *  <tr class="tableSubHeadingColor">
+ *  <th class="colFirst" align="left">year-of-era</th>
+ *  <th class="colFirst" align="left">era</th>
+ *  <th class="colLast" align="left">proleptic-year</th>
+ *  </tr>
+ *  </thead>
+ *  <tbody>
+ *  <tr class="rowColor">
+ *  <td>2</td><td>CE</td><td>2</td>
+ *  </tr>
+ *  <tr class="altColor">
+ *  <td>1</td><td>CE</td><td>1</td>
+ *  </tr>
+ *  <tr class="rowColor">
+ *  <td>1</td><td>BCE</td><td>0</td>
+ *  </tr>
+ *  <tr class="altColor">
+ *  <td>2</td><td>BCE</td><td>-1</td>
+ *  </tr>
+ *  </tbody>
+ *  </table>
+ *  <p>
+ *  <b>Do not use {@code ordinal()} to obtain the numeric representation of {@code IsoEra}.
+ *  Use {@code getValue()} instead.</b>
+ * @implSpec This is an immutable and thread-safe enum.
+ * @since 1.8
+ */
+export type IsoEra = {
+  BCE: "BCE";
+  CE: "CE";
+};

package/types/java/time/chrono/IsoEra/index.js

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  BCE: "BCE",
+  CE: "CE"
+};
+exports["default"] = _default;