@sitevision/api 2023.2.2-beta.1 → 2023.2.2-beta.3

package/types/java/time/ZonedDateTime/index.d.ts

@@ -1,26 +1,21 @@
-import type { ZoneId } from "../ZoneId";
-import type { Clock } from "../Clock";
-import type { LocalDate } from "../LocalDate";
-import type { LocalTime } from "../LocalTime";
-import type { LocalDateTime } from "../LocalDateTime";
-
-import type { ZoneOffset } from "../ZoneOffset";
-import type { Instant } from "../Instant";
-import type { TemporalAccessor } from "../temporal/TemporalAccessor";
-import type { CharSequence } from "../../lang/CharSequence";
-import type { DateTimeFormatter } from "../format/DateTimeFormatter";
 import type { TemporalField } from "../temporal/TemporalField";
 
 import type { TemporalUnit } from "../temporal/TemporalUnit";
 import type { ValueRange } from "../temporal/ValueRange";
 
+import type { ZoneOffset } from "../ZoneOffset";
+import type { ZoneId } from "../ZoneId";
+import type { LocalDateTime } from "../LocalDateTime";
+import type { LocalDate } from "../LocalDate";
 import type { Month } from "../Month";
 import type { DayOfWeek } from "../DayOfWeek";
+import type { LocalTime } from "../LocalTime";
 import type { TemporalAdjuster } from "../temporal/TemporalAdjuster";
 import type { TemporalAmount } from "../temporal/TemporalAmount";
 import type { TemporalQuery } from "../temporal/TemporalQuery";
 
 import type { Temporal } from "../temporal/Temporal";
+import type { DateTimeFormatter } from "../format/DateTimeFormatter";
 import type { String } from "../../lang/String";
 import type { OffsetDateTime } from "../OffsetDateTime";
 import type { Object } from "../../lang/Object";
@@ -92,279 +87,6 @@ export type ZonedDateTime = Object &
   Temporal &
   ChronoZonedDateTime &
   Serializable & {
-    /**
-     * Obtains the current date-time 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-time.
-     *  The zone and offset will be set based on the time-zone in the clock.
-     *  <p>
-     *  Using this method will prevent the ability to use an alternate clock for testing
-     *  because the clock is hard-coded.
-     * @return the current date-time using the system clock, not null
-     */
-    now(): ZonedDateTime;
-
-    /**
-     * Obtains the current date-time 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-time.
-     *  Specifying the time-zone avoids dependence on the default time-zone.
-     *  The offset will be calculated from the specified time-zone.
-     *  <p>
-     *  Using this method will prevent the ability to use an alternate clock for testing
-     *  because the clock is hard-coded.
-     * @param zone the zone ID to use, not null
-     * @return the current date-time using the system clock, not null
-     */
-    now(zone: ZoneId): ZonedDateTime;
-
-    /**
-     * Obtains the current date-time from the specified clock.
-     *  <p>
-     *  This will query the specified clock to obtain the current date-time.
-     *  The zone and offset will be set based on the time-zone in the clock.
-     *  <p>
-     *  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 date-time, not null
-     */
-    now(clock: Clock): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from a local date and time.
-     *  <p>
-     *  This creates a zoned date-time matching the input local date and time as closely as possible.
-     *  Time-zone rules, such as daylight savings, mean that not every local date-time
-     *  is valid for the specified zone, thus the local date-time may be adjusted.
-     *  <p>
-     *  The local date time and first combined to form a local date-time.
-     *  The local date-time is then resolved to a single instant on the time-line.
-     *  This is achieved by finding a valid offset from UTC/Greenwich for the local
-     *  date-time as defined by the {@link ZoneRules rules} of the zone ID.
-     * <p>
-     *  In most cases, there is only one valid offset for a local date-time.
-     *  In the case of an overlap, when clocks are set back, there are two valid offsets.
-     *  This method uses the earlier offset typically corresponding to "summer".
-     *  <p>
-     *  In the case of a gap, when clocks jump forward, there is no valid offset.
-     *  Instead, the local date-time is adjusted to be later by the length of the gap.
-     *  For a typical one hour daylight savings change, the local date-time will be
-     *  moved one hour later into the offset typically corresponding to "summer".
-     * @param date the local date, not null
-     * @param time the local time, not null
-     * @param zone the time-zone, not null
-     * @return the offset date-time, not null
-     */
-    of(date: LocalDate, time: LocalTime, zone: ZoneId): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from a local date-time.
-     *  <p>
-     *  This creates a zoned date-time matching the input local date-time as closely as possible.
-     *  Time-zone rules, such as daylight savings, mean that not every local date-time
-     *  is valid for the specified zone, thus the local date-time may be adjusted.
-     *  <p>
-     *  The local date-time is resolved to a single instant on the time-line.
-     *  This is achieved by finding a valid offset from UTC/Greenwich for the local
-     *  date-time as defined by the {@link ZoneRules rules} of the zone ID.
-     * <p>
-     *  In most cases, there is only one valid offset for a local date-time.
-     *  In the case of an overlap, when clocks are set back, there are two valid offsets.
-     *  This method uses the earlier offset typically corresponding to "summer".
-     *  <p>
-     *  In the case of a gap, when clocks jump forward, there is no valid offset.
-     *  Instead, the local date-time is adjusted to be later by the length of the gap.
-     *  For a typical one hour daylight savings change, the local date-time will be
-     *  moved one hour later into the offset typically corresponding to "summer".
-     * @param localDateTime the local date-time, not null
-     * @param zone the time-zone, not null
-     * @return the zoned date-time, not null
-     */
-    of(localDateTime: LocalDateTime, zone: ZoneId): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from a year, month, day,
-     *  hour, minute, second, nanosecond and time-zone.
-     *  <p>
-     *  This creates a zoned date-time matching the local date-time of the seven
-     *  specified fields as closely as possible.
-     *  Time-zone rules, such as daylight savings, mean that not every local date-time
-     *  is valid for the specified zone, thus the local date-time may be adjusted.
-     *  <p>
-     *  The local date-time is resolved to a single instant on the time-line.
-     *  This is achieved by finding a valid offset from UTC/Greenwich for the local
-     *  date-time as defined by the {@link ZoneRules rules} of the zone ID.
-     * <p>
-     *  In most cases, there is only one valid offset for a local date-time.
-     *  In the case of an overlap, when clocks are set back, there are two valid offsets.
-     *  This method uses the earlier offset typically corresponding to "summer".
-     *  <p>
-     *  In the case of a gap, when clocks jump forward, there is no valid offset.
-     *  Instead, the local date-time is adjusted to be later by the length of the gap.
-     *  For a typical one hour daylight savings change, the local date-time will be
-     *  moved one hour later into the offset typically corresponding to "summer".
-     *  <p>
-     *  This method exists primarily for writing test cases.
-     *  Non test-code will typically use other methods to create an offset time.
-     *  {@code LocalDateTime} has five additional convenience variants of the
-     *  equivalent factory method taking fewer arguments.
-     *  They are not provided here to reduce the footprint of the API.
-     * @param year the year to represent, from MIN_YEAR to MAX_YEAR
-     * @param month the month-of-year to represent, from 1 (January) to 12 (December)
-     * @param dayOfMonth the day-of-month to represent, from 1 to 31
-     * @param hour the hour-of-day to represent, from 0 to 23
-     * @param minute the minute-of-hour to represent, from 0 to 59
-     * @param second the second-of-minute to represent, from 0 to 59
-     * @param nanoOfSecond the nano-of-second to represent, from 0 to 999,999,999
-     * @param zone the time-zone, not null
-     * @return the offset date-time, not null
-     * @throws DateTimeException if the value of any field is out of range, or&#xA; if the day-of-month is invalid for the month-year
-     */
-    of(
-      year: number,
-      month: number,
-      dayOfMonth: number,
-      hour: number,
-      minute: number,
-      second: number,
-      nanoOfSecond: number,
-      zone: ZoneId
-    ): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from a local date-time
-     *  using the preferred offset if possible.
-     *  <p>
-     *  The local date-time is resolved to a single instant on the time-line.
-     *  This is achieved by finding a valid offset from UTC/Greenwich for the local
-     *  date-time as defined by the {@link ZoneRules rules} of the zone ID.
-     * <p>
-     *  In most cases, there is only one valid offset for a local date-time.
-     *  In the case of an overlap, where clocks are set back, there are two valid offsets.
-     *  If the preferred offset is one of the valid offsets then it is used.
-     *  Otherwise the earlier valid offset is used, typically corresponding to "summer".
-     *  <p>
-     *  In the case of a gap, where clocks jump forward, there is no valid offset.
-     *  Instead, the local date-time is adjusted to be later by the length of the gap.
-     *  For a typical one hour daylight savings change, the local date-time will be
-     *  moved one hour later into the offset typically corresponding to "summer".
-     * @param localDateTime the local date-time, not null
-     * @param zone the time-zone, not null
-     * @param preferredOffset the zone offset, null if no preference
-     * @return the zoned date-time, not null
-     */
-    ofLocal(
-      localDateTime: LocalDateTime,
-      zone: ZoneId,
-      preferredOffset: ZoneOffset
-    ): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from an {@code Instant}.
-     *  <p>
-     *  This creates a zoned date-time with the same instant as that specified.
-     *  Calling {@link #toInstant()} will return an instant equal to the one used here.
-     *  <p>
-     *  Converting an instant to a zoned date-time is simple as there is only one valid
-     *  offset for each instant.
-     * @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
-     */
-    ofInstant(instant: Instant, zone: ZoneId): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from the instant formed by combining
-     *  the local date-time and offset.
-     *  <p>
-     *  This creates a zoned date-time by {@link LocalDateTime#toInstant(ZoneOffset) combining}
-     *  the {@code LocalDateTime} and {@code ZoneOffset}.
-     *  This combination uniquely specifies an instant without ambiguity.
-     *  <p>
-     *  Converting an instant to a zoned date-time is simple as there is only one valid
-     *  offset for each instant. If the valid offset is different to the offset specified,
-     *  then the date-time and offset of the zoned date-time will differ from those specified.
-     *  <p>
-     *  If the {@code ZoneId} to be used is a {@code ZoneOffset}, this method is equivalent
-     *  to {@link #of(LocalDateTime, ZoneId)}.
-     * @param localDateTime the local date-time, not null
-     * @param offset the zone offset, not null
-     * @param zone the time-zone, not null
-     * @return the zoned date-time, not null
-     */
-    ofInstant(
-      localDateTime: LocalDateTime,
-      offset: ZoneOffset,
-      zone: ZoneId
-    ): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} strictly validating the
-     *  combination of local date-time, offset and zone ID.
-     *  <p>
-     *  This creates a zoned date-time ensuring that the offset is valid for the
-     *  local date-time according to the rules of the specified zone.
-     *  If the offset is invalid, an exception is thrown.
-     * @param localDateTime the local date-time, not null
-     * @param offset the zone offset, not null
-     * @param zone the time-zone, not null
-     * @return the zoned date-time, not null
-     */
-    ofStrict(
-      localDateTime: LocalDateTime,
-      offset: ZoneOffset,
-      zone: ZoneId
-    ): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from a temporal object.
-     *  <p>
-     *  This obtains a zoned date-time based on the specified temporal.
-     *  A {@code TemporalAccessor} represents an arbitrary set of date and time information,
-     *  which this factory converts to an instance of {@code ZonedDateTime}.
-     *  <p>
-     *  The conversion will first obtain a {@code ZoneId} from the temporal object,
-     *  falling back to a {@code ZoneOffset} if necessary. It will then try to obtain
-     *  an {@code Instant}, falling back to a {@code LocalDateTime} if necessary.
-     *  The result will be either the combination of {@code ZoneId} or {@code ZoneOffset}
-     *  with {@code Instant} or {@code LocalDateTime}.
-     *  Implementations are permitted to perform optimizations such as accessing
-     *  those fields that are equivalent to the relevant objects.
-     *  <p>
-     *  This method matches the signature of the functional interface {@link TemporalQuery}
-     *  allowing it to be used as a query via method reference, {@code ZonedDateTime::from}.
-     * @param temporal the temporal object to convert, not null
-     * @return the zoned date-time, not null
-     * @throws DateTimeException if unable to convert to an {@code ZonedDateTime}
-     */
-    from(temporal: TemporalAccessor): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from a text string such as
-     *  {@code 2007-12-03T10:15:30+01:00[Europe/Paris]}.
-     *  <p>
-     *  The string must represent a valid date-time and is parsed using
-     *  {@link java.time.format.DateTimeFormatter#ISO_ZONED_DATE_TIME}.
-     * @param text the text to parse such as "2007-12-03T10:15:30+01:00[Europe/Paris]", not null
-     * @return the parsed zoned date-time, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence): ZonedDateTime;
-
-    /**
-     * Obtains an instance of {@code ZonedDateTime} from a text string using a specific formatter.
-     *  <p>
-     *  The text is parsed using the formatter, returning a date-time.
-     * @param text the text to parse, not null
-     * @param formatter the formatter to use, not null
-     * @return the parsed zoned date-time, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence, formatter: DateTimeFormatter): ZonedDateTime;
-
     /**
      * Checks if the specified field is supported.
      *  <p>

package/types/java/time/ZonedDateTime/index.js

@@ -5,13 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var _default = {
-  now: function now() {},
-  of: function of() {},
-  ofLocal: function ofLocal() {},
-  ofInstant: function ofInstant() {},
-  ofStrict: function ofStrict() {},
-  from: function from() {},
-  parse: function parse() {},
   isSupported: function isSupported() {},
   range: function range() {},
   get: function get() {},

package/types/java/time/format/DateTimeFormatter/index.d.ts

@@ -1,7 +1,4 @@
-import type { String } from "../../../lang/String";
 import type { Locale } from "../../../util/Locale";
-import type { FormatStyle } from "../FormatStyle";
-import type { TemporalQuery } from "../../temporal/TemporalQuery";
 import type { DecimalStyle } from "../DecimalStyle";
 import type { Chronology } from "../../chrono/Chronology";
 import type { ZoneId } from "../../ZoneId";
@@ -9,10 +6,12 @@ import type { ResolverStyle } from "../ResolverStyle";
 import type { Set } from "../../../util/Set";
 import type { TemporalField } from "../../temporal/TemporalField";
 import type { TemporalAccessor } from "../../temporal/TemporalAccessor";
+import type { String } from "../../../lang/String";
 import type { Appendable } from "../../../lang/Appendable";
 
 import type { CharSequence } from "../../../lang/CharSequence";
 import type { ParsePosition } from "../../../text/ParsePosition";
+import type { TemporalQuery } from "../../temporal/TemporalQuery";
 
 import type { Format } from "../../../text/Format";
 import type { Object } from "../../../lang/Object";
@@ -398,218 +397,6 @@ import type { Object } from "../../../lang/Object";
  * @since 1.8
  */
 export type DateTimeFormatter = Object & {
-  /**
-   * Creates a formatter using the specified pattern.
-   *  <p>
-   *  This method will create a formatter based on a simple
-   *  <a href="#patterns">pattern of letters and symbols</a>
-   *  as described in the class documentation.
-   *  For example, {@code d MMM uuuu} will format 2011-12-03 as '3 Dec 2011'.
-   *  <p>
-   *  The formatter will use the {@link Locale#getDefault(Locale.Category) default FORMAT locale}.
-   *  This can be changed using {@link DateTimeFormatter#withLocale(Locale)} on the returned formatter
-   *  Alternatively use the {@link #ofPattern(String, Locale)} variant of this method.
-   *  <p>
-   *  The returned formatter has no override chronology or zone.
-   *  It uses {@link ResolverStyle#SMART SMART} resolver style.
-   * @param pattern the pattern to use, not null
-   * @return the formatter based on the pattern, not null
-   * @throws IllegalArgumentException if the pattern is invalid
-   * @see DateTimeFormatterBuilder#appendPattern(String)
-   */
-  ofPattern(pattern: String | string): DateTimeFormatter;
-
-  /**
-   * Creates a formatter using the specified pattern and locale.
-   *  <p>
-   *  This method will create a formatter based on a simple
-   *  <a href="#patterns">pattern of letters and symbols</a>
-   *  as described in the class documentation.
-   *  For example, {@code d MMM uuuu} will format 2011-12-03 as '3 Dec 2011'.
-   *  <p>
-   *  The formatter will use the specified locale.
-   *  This can be changed using {@link DateTimeFormatter#withLocale(Locale)} on the returned formatter
-   *  <p>
-   *  The returned formatter has no override chronology or zone.
-   *  It uses {@link ResolverStyle#SMART SMART} resolver style.
-   * @param pattern the pattern to use, not null
-   * @param locale the locale to use, not null
-   * @return the formatter based on the pattern, not null
-   * @throws IllegalArgumentException if the pattern is invalid
-   * @see DateTimeFormatterBuilder#appendPattern(String)
-   */
-  ofPattern(pattern: String | string, locale: Locale): DateTimeFormatter;
-
-  /**
-   * Returns a locale specific date format for the ISO chronology.
-   *  <p>
-   *  This returns a formatter that will format or parse a date.
-   *  The exact format pattern used varies by locale.
-   *  <p>
-   *  The locale is determined from the formatter. The formatter returned directly by
-   *  this method will use the {@link Locale#getDefault(Locale.Category) default FORMAT locale}.
-   *  The locale can be controlled using {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)}
-   *  on the result of this method.
-   *  <p>
-   *  Note that the localized pattern is looked up lazily.
-   *  This {@code DateTimeFormatter} holds the style required and the locale,
-   *  looking up the pattern required on demand.
-   *  <p>
-   *  The returned formatter has a chronology of ISO set to ensure dates in
-   *  other calendar systems are correctly converted.
-   *  It has no override zone and uses the {@link ResolverStyle#SMART SMART} resolver style.
-   * @param dateStyle the formatter style to obtain, not null
-   * @return the date formatter, not null
-   */
-  ofLocalizedDate(dateStyle: FormatStyle): DateTimeFormatter;
-
-  /**
-   * Returns a locale specific time format for the ISO chronology.
-   *  <p>
-   *  This returns a formatter that will format or parse a time.
-   *  The exact format pattern used varies by locale.
-   *  <p>
-   *  The locale is determined from the formatter. The formatter returned directly by
-   *  this method will use the {@link Locale#getDefault(Locale.Category) default FORMAT locale}.
-   *  The locale can be controlled using {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)}
-   *  on the result of this method.
-   *  <p>
-   *  Note that the localized pattern is looked up lazily.
-   *  This {@code DateTimeFormatter} holds the style required and the locale,
-   *  looking up the pattern required on demand.
-   *  <p>
-   *  The returned formatter has a chronology of ISO set to ensure dates in
-   *  other calendar systems are correctly converted.
-   *  It has no override zone and uses the {@link ResolverStyle#SMART SMART} resolver style.
-   * @param timeStyle the formatter style to obtain, not null
-   * @return the time formatter, not null
-   */
-  ofLocalizedTime(timeStyle: FormatStyle): DateTimeFormatter;
-
-  /**
-   * Returns a locale specific date-time formatter for the ISO chronology.
-   *  <p>
-   *  This returns a formatter that will format or parse a date-time.
-   *  The exact format pattern used varies by locale.
-   *  <p>
-   *  The locale is determined from the formatter. The formatter returned directly by
-   *  this method will use the {@link Locale#getDefault(Locale.Category) default FORMAT locale}.
-   *  The locale can be controlled using {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)}
-   *  on the result of this method.
-   *  <p>
-   *  Note that the localized pattern is looked up lazily.
-   *  This {@code DateTimeFormatter} holds the style required and the locale,
-   *  looking up the pattern required on demand.
-   *  <p>
-   *  The returned formatter has a chronology of ISO set to ensure dates in
-   *  other calendar systems are correctly converted.
-   *  It has no override zone and uses the {@link ResolverStyle#SMART SMART} resolver style.
-   * @param dateTimeStyle the formatter style to obtain, not null
-   * @return the date-time formatter, not null
-   */
-  ofLocalizedDateTime(dateTimeStyle: FormatStyle): DateTimeFormatter;
-
-  /**
-   * Returns a locale specific date and time format for the ISO chronology.
-   *  <p>
-   *  This returns a formatter that will format or parse a date-time.
-   *  The exact format pattern used varies by locale.
-   *  <p>
-   *  The locale is determined from the formatter. The formatter returned directly by
-   *  this method will use the {@link Locale#getDefault() default FORMAT locale}.
-   *  The locale can be controlled using {@link DateTimeFormatter#withLocale(Locale) withLocale(Locale)}
-   *  on the result of this method.
-   *  <p>
-   *  Note that the localized pattern is looked up lazily.
-   *  This {@code DateTimeFormatter} holds the style required and the locale,
-   *  looking up the pattern required on demand.
-   *  <p>
-   *  The returned formatter has a chronology of ISO set to ensure dates in
-   *  other calendar systems are correctly converted.
-   *  It has no override zone and uses the {@link ResolverStyle#SMART SMART} resolver style.
-   * @param dateStyle the date formatter style to obtain, not null
-   * @param timeStyle the time formatter style to obtain, not null
-   * @return the date, time or date-time formatter, not null
-   */
-  ofLocalizedDateTime(
-    dateStyle: FormatStyle,
-    timeStyle: FormatStyle
-  ): DateTimeFormatter;
-
-  /**
-   * A query that provides access to the excess days that were parsed.
-   *  <p>
-   *  This returns a singleton {@linkplain TemporalQuery query} that provides
-   *  access to additional information from the parse. The query always returns
-   *  a non-null period, with a zero period returned instead of null.
-   *  <p>
-   *  There are two situations where this query may return a non-zero period.
-   *  <ul>
-   *  <li>If the {@code ResolverStyle} is {@code LENIENT} and a time is parsed
-   *   without a date, then the complete result of the parse consists of a
-   *   {@code LocalTime} and an excess {@code Period} in days.
-   *
-   *  <li>If the {@code ResolverStyle} is {@code SMART} and a time is parsed
-   *   without a date where the time is 24:00:00, then the complete result of
-   *   the parse consists of a {@code LocalTime} of 00:00:00 and an excess
-   *   {@code Period} of one day.
-   *  </ul>
-   *  <p>
-   *  In both cases, if a complete {@code ChronoLocalDateTime} or {@code Instant}
-   *  is parsed, then the excess days are added to the date part.
-   *  As a result, this query will return a zero period.
-   *  <p>
-   *  The {@code SMART} behaviour handles the common "end of day" 24:00 value.
-   *  Processing in {@code LENIENT} mode also produces the same result:
-   *  <pre>
-   *   Text to parse        Parsed object                         Excess days
-   *   "2012-12-03T00:00"   LocalDateTime.of(2012, 12, 3, 0, 0)   ZERO
-   *   "2012-12-03T24:00"   LocalDateTime.of(2012, 12, 4, 0, 0)   ZERO
-   *   "00:00"              LocalTime.of(0, 0)                    ZERO
-   *   "24:00"              LocalTime.of(0, 0)                    Period.ofDays(1)
-   *  </pre>
-   *  The query can be used as follows:
-   *  <pre>
-   *   TemporalAccessor parsed = formatter.parse(str);
-   *   LocalTime time = parsed.query(LocalTime::from);
-   *   Period extraDays = parsed.query(DateTimeFormatter.parsedExcessDays());
-   *  </pre>
-   * @return a query that provides access to the excess days that were parsed
-   */
-  parsedExcessDays(): TemporalQuery;
-
-  /**
-   * A query that provides access to whether a leap-second was parsed.
-   *  <p>
-   *  This returns a singleton {@linkplain TemporalQuery query} that provides
-   *  access to additional information from the parse. The query always returns
-   *  a non-null boolean, true if parsing saw a leap-second, false if not.
-   *  <p>
-   *  Instant parsing handles the special "leap second" time of '23:59:60'.
-   *  Leap seconds occur at '23:59:60' in the UTC time-zone, but at other
-   *  local times in different time-zones. To avoid this potential ambiguity,
-   *  the handling of leap-seconds is limited to
-   *  {@link DateTimeFormatterBuilder#appendInstant()}, as that method
-   *  always parses the instant with the UTC zone offset.
-   *  <p>
-   *  If the time '23:59:60' is received, then a simple conversion is applied,
-   *  replacing the second-of-minute of 60 with 59. This query can be used
-   *  on the parse result to determine if the leap-second adjustment was made.
-   *  The query will return {@code true} if it did adjust to remove the
-   *  leap-second, and {@code false} if not. Note that applying a leap-second
-   *  smoothing mechanism, such as UTC-SLS, is the responsibility of the
-   *  application, as follows:
-   *  <pre>
-   *   TemporalAccessor parsed = formatter.parse(str);
-   *   Instant instant = parsed.query(Instant::from);
-   *   if (parsed.query(DateTimeFormatter.parsedLeapSecond())) {
-   *     // validate leap-second is correct and apply correct smoothing
-   *   }
-   *  </pre>
-   * @return a query that provides access to whether a leap-second was parsed
-   */
-  parsedLeapSecond(): TemporalQuery;
-
   /**
    * Gets the locale to be used during formatting.
    *  <p>
@@ -817,7 +604,7 @@ export type DateTimeFormatter = Object & {
    * @param resolverFields the new set of resolver fields, null if no fields
    * @return a formatter based on this formatter with the requested resolver style, not null
    */
-  withResolverFields(resolverFields: TemporalField[]): DateTimeFormatter;
+  withResolverFields(...resolverFields: TemporalField[]): DateTimeFormatter;
 
   /**
    * Returns a copy of this formatter with a new set of resolver fields.
@@ -980,7 +767,7 @@ export type DateTimeFormatter = Object & {
    * @throws IllegalArgumentException if less than 2 types are specified
    * @throws DateTimeParseException if unable to parse the requested result
    */
-  parseBest(text: CharSequence, queries: TemporalQuery[]): TemporalAccessor;
+  parseBest(text: CharSequence, ...queries: TemporalQuery[]): TemporalAccessor;
 
   /**
    * Parses the text using this formatter, without resolving the result, intended

package/types/java/time/format/DateTimeFormatter/index.js

@@ -5,12 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var _default = {
-  ofPattern: function ofPattern() {},
-  ofLocalizedDate: function ofLocalizedDate() {},
-  ofLocalizedTime: function ofLocalizedTime() {},
-  ofLocalizedDateTime: function ofLocalizedDateTime() {},
-  parsedExcessDays: function parsedExcessDays() {},
-  parsedLeapSecond: function parsedLeapSecond() {},
   getLocale: function getLocale() {},
   withLocale: function withLocale() {},
   getDecimalStyle: function getDecimalStyle() {},

package/types/java/time/format/DecimalStyle/index.d.ts

@@ -1,6 +1,3 @@
-import type { Set } from "../../../util/Set";
-import type { Locale } from "../../../util/Locale";
-
 import type { Object } from "../../../lang/Object";
 
 import type { String } from "../../../lang/String";
@@ -14,37 +11,6 @@ import type { String } from "../../../lang/String";
  * @since 1.8
  */
 export type DecimalStyle = Object & {
-  /**
-   * Lists all the locales that are supported.
-   *  <p>
-   *  The locale 'en_US' will always be present.
-   * @return a Set of Locales for which localization is supported
-   */
-  getAvailableLocales(): Set;
-
-  /**
-   * Obtains the DecimalStyle for the default
-   *  {@link java.util.Locale.Category#FORMAT FORMAT} locale.
-   *  <p>
-   *  This method provides access to locale sensitive decimal style symbols.
-   *  <p>
-   *  This is equivalent to calling
-   *  {@link #of(Locale)
-   *      of(Locale.getDefault(Locale.Category.FORMAT))}.
-   * @see java.util.Locale.Category#FORMAT
-   * @return the decimal style, not null
-   */
-  ofDefaultLocale(): DecimalStyle;
-
-  /**
-   * Obtains the DecimalStyle for the specified locale.
-   *  <p>
-   *  This method provides access to locale sensitive decimal style symbols.
-   * @param locale the locale, not null
-   * @return the decimal style, not null
-   */
-  of(locale: Locale): DecimalStyle;
-
   /**
    * Gets the character that represents zero.
    *  <p>

package/types/java/time/format/DecimalStyle/index.js

@@ -5,9 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var _default = {
-  getAvailableLocales: function getAvailableLocales() {},
-  ofDefaultLocale: function ofDefaultLocale() {},
-  of: function of() {},
   getZeroDigit: function getZeroDigit() {},
   withZeroDigit: function withZeroDigit() {},
   getPositiveSign: function getPositiveSign() {},