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

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

@@ -1,14 +1,11 @@
-import type { Set } from "../../util/Set";
 import type { String } from "../../lang/String";
-import type { Map } from "../../util/Map";
-import type { ZoneOffset } from "../ZoneOffset";
-import type { TemporalAccessor } from "../temporal/TemporalAccessor";
 import type { TextStyle } from "../format/TextStyle";
 import type { Locale } from "../../util/Locale";
 import type { ZoneRules } from "../zone/ZoneRules";
 import type { Object } from "../../lang/Object";
 
 import type { Serializable } from "../../io/Serializable";
+import type { Map } from "../../util/Map";
 
 /**
  * A time-zone ID, such as {@code Europe/Paris}.
@@ -97,123 +94,6 @@ import type { Serializable } from "../../io/Serializable";
  */
 export type ZoneId = Object &
   Serializable & {
-    /**
-     * Gets the system default time-zone.
-     *  <p>
-     *  This queries {@link TimeZone#getDefault()} to find the default time-zone
-     *  and converts it to a {@code ZoneId}. If the system default time-zone is changed,
-     *  then the result of this method will also change.
-     * @return the zone ID, not null
-     * @throws DateTimeException if the converted zone ID has an invalid format
-     * @throws ZoneRulesException if the converted zone region ID cannot be found
-     */
-    systemDefault(): ZoneId;
-
-    /**
-     * Gets the set of available zone IDs.
-     *  <p>
-     *  This set includes the string form of all available region-based IDs.
-     *  Offset-based zone IDs are not included in the returned set.
-     *  The ID can be passed to {@link #of(String)} to create a {@code ZoneId}.
-     *  <p>
-     *  The set of zone IDs can increase over time, although in a typical application
-     *  the set of IDs is fixed. Each call to this method is thread-safe.
-     * @return a modifiable copy of the set of zone IDs, not null
-     */
-    getAvailableZoneIds(): Set;
-
-    /**
-     * Obtains an instance of {@code ZoneId} using its ID using a map
-     *  of aliases to supplement the standard zone IDs.
-     *  <p>
-     *  Many users of time-zones use short abbreviations, such as PST for
-     *  'Pacific Standard Time' and PDT for 'Pacific Daylight Time'.
-     *  These abbreviations are not unique, and so cannot be used as IDs.
-     *  This method allows a map of string to time-zone to be setup and reused
-     *  within an application.
-     * @param zoneId the time-zone ID, not null
-     * @param aliasMap a map of alias zone IDs (typically abbreviations) to real zone IDs, not null
-     * @return the zone ID, not null
-     * @throws DateTimeException if the zone ID has an invalid format
-     * @throws ZoneRulesException if the zone ID is a region ID that cannot be found
-     */
-    of(zoneId: String | string, aliasMap: Map | {}): ZoneId;
-
-    /**
-     * Obtains an instance of {@code ZoneId} from an ID ensuring that the
-     *  ID is valid and available for use.
-     *  <p>
-     *  This method parses the ID producing a {@code ZoneId} or {@code ZoneOffset}.
-     *  A {@code ZoneOffset} is returned if the ID is 'Z', or starts with '+' or '-'.
-     *  The result will always be a valid ID for which {@link ZoneRules} can be obtained.
-     *  <p>
-     *  Parsing matches the zone ID step by step as follows.
-     *  <ul>
-     *  <li>If the zone ID equals 'Z', the result is {@code ZoneOffset.UTC}.
-     *  <li>If the zone ID consists of a single letter, the zone ID is invalid
-     *   and {@code DateTimeException} is thrown.
-     *  <li>If the zone ID starts with '+' or '-', the ID is parsed as a
-     *   {@code ZoneOffset} using {@link ZoneOffset#of(String)}.
-     *  <li>If the zone ID equals 'GMT', 'UTC' or 'UT' then the result is a {@code ZoneId}
-     *   with the same ID and rules equivalent to {@code ZoneOffset.UTC}.
-     *  <li>If the zone ID starts with 'UTC+', 'UTC-', 'GMT+', 'GMT-', 'UT+' or 'UT-'
-     *   then the ID is a prefixed offset-based ID. The ID is split in two, with
-     *   a two or three letter prefix and a suffix starting with the sign.
-     *   The suffix is parsed as a {@link ZoneOffset#of(String) ZoneOffset}.
-     *   The result will be a {@code ZoneId} with the specified UTC/GMT/UT prefix
-     *   and the normalized offset ID as per {@link ZoneOffset#getId()}.
-     *   The rules of the returned {@code ZoneId} will be equivalent to the
-     *   parsed {@code ZoneOffset}.
-     *  <li>All other IDs are parsed as region-based zone IDs. Region IDs must
-     *   match the regular expression <code>[A-Za-z][A-Za-z0-9~/._+-]+</code>
-     *   otherwise a {@code DateTimeException} is thrown. If the zone ID is not
-     *   in the configured set of IDs, {@code ZoneRulesException} is thrown.
-     *   The detailed format of the region ID depends on the group supplying the data.
-     *   The default set of data is supplied by the IANA Time Zone Database (TZDB).
-     *   This has region IDs of the form '{area}/{city}', such as 'Europe/Paris' or 'America/New_York'.
-     *   This is compatible with most IDs from {@link java.util.TimeZone}.
-     *  </ul>
-     * @param zoneId the time-zone ID, not null
-     * @return the zone ID, not null
-     * @throws DateTimeException if the zone ID has an invalid format
-     * @throws ZoneRulesException if the zone ID is a region ID that cannot be found
-     */
-    of(zoneId: String | string): ZoneId;
-
-    /**
-     * Obtains an instance of {@code ZoneId} wrapping an offset.
-     *  <p>
-     *  If the prefix is "GMT", "UTC", or "UT" a {@code ZoneId}
-     *  with the prefix and the non-zero offset is returned.
-     *  If the prefix is empty {@code ""} the {@code ZoneOffset} is returned.
-     * @param prefix the time-zone ID, not null
-     * @param offset the offset, not null
-     * @return the zone ID, not null
-     * @throws IllegalArgumentException if the prefix is not one of&#xA; "GMT", "UTC", or "UT", or ""
-     */
-    ofOffset(prefix: String | string, offset: ZoneOffset): ZoneId;
-
-    /**
-     * Obtains an instance of {@code ZoneId} from a temporal object.
-     *  <p>
-     *  This obtains a zone 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 ZoneId}.
-     *  <p>
-     *  A {@code TemporalAccessor} represents some form of date and time information.
-     *  This factory converts the arbitrary temporal object to an instance of {@code ZoneId}.
-     *  <p>
-     *  The conversion will try to obtain the zone in a way that favours region-based
-     *  zones over offset-based zones using {@link TemporalQueries#zone()}.
-     *  <p>
-     *  This method matches the signature of the functional interface {@link TemporalQuery}
-     *  allowing it to be used as a query via method reference, {@code ZoneId::from}.
-     * @param temporal the temporal object to convert, not null
-     * @return the zone ID, not null
-     * @throws DateTimeException if unable to convert to a {@code ZoneId}
-     */
-    from(temporal: TemporalAccessor): ZoneId;
-
     /**
      * Gets the unique time-zone ID.
      *  <p>

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

@@ -5,11 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var _default = {
-  systemDefault: function systemDefault() {},
-  getAvailableZoneIds: function getAvailableZoneIds() {},
-  of: function of() {},
-  ofOffset: function ofOffset() {},
-  from: function from() {},
   getId: function getId() {},
   getDisplayName: function getDisplayName() {},
   getRules: function getRules() {},

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

@@ -1,6 +1,4 @@
 import type { String } from "../../lang/String";
-
-import type { TemporalAccessor } from "../temporal/TemporalAccessor";
 import type { ZoneRules } from "../zone/ZoneRules";
 import type { TemporalField } from "../temporal/TemporalField";
 
@@ -11,6 +9,7 @@ import type { TemporalQuery } from "../temporal/TemporalQuery";
 import type { Temporal } from "../temporal/Temporal";
 import type { Object } from "../../lang/Object";
 import type { ZoneId } from "../ZoneId";
+import type { TemporalAccessor } from "../temporal/TemporalAccessor";
 import type { TemporalAdjuster } from "../temporal/TemporalAdjuster";
 import type { Comparable } from "../../lang/Comparable";
 import type { Serializable } from "../../io/Serializable";
@@ -58,108 +57,6 @@ export type ZoneOffset = ZoneId &
   TemporalAdjuster &
   Comparable &
   Serializable & {
-    /**
-     * Obtains an instance of {@code ZoneOffset} using the ID.
-     *  <p>
-     *  This method parses the string ID of a {@code ZoneOffset} to
-     *  return an instance. The parsing accepts all the formats generated by
-     *  {@link #getId()}, plus some additional formats:
-     *  <ul>
-     *  <li>{@code Z} - for UTC
-     *  <li>{@code +h}
-     *  <li>{@code +hh}
-     *  <li>{@code +hh:mm}
-     *  <li>{@code -hh:mm}
-     *  <li>{@code +hhmm}
-     *  <li>{@code -hhmm}
-     *  <li>{@code +hh:mm:ss}
-     *  <li>{@code -hh:mm:ss}
-     *  <li>{@code +hhmmss}
-     *  <li>{@code -hhmmss}
-     *  </ul>
-     *  Note that &plusmn; means either the plus or minus symbol.
-     *  <p>
-     *  The ID of the returned offset will be normalized to one of the formats
-     *  described by {@link #getId()}.
-     *  <p>
-     *  The maximum supported range is from +18:00 to -18:00 inclusive.
-     * @param offsetId the offset ID, not null
-     * @return the zone-offset, not null
-     * @throws DateTimeException if the offset ID is invalid
-     */
-    of(offsetId: String | string): ZoneOffset;
-
-    /**
-     * Obtains an instance of {@code ZoneOffset} using an offset in hours.
-     * @param hours the time-zone offset in hours, from -18 to +18
-     * @return the zone-offset, not null
-     * @throws DateTimeException if the offset is not in the required range
-     */
-    ofHours(hours: number): ZoneOffset;
-
-    /**
-     * Obtains an instance of {@code ZoneOffset} using an offset in
-     *  hours and minutes.
-     *  <p>
-     *  The sign of the hours and minutes components must match.
-     *  Thus, if the hours is negative, the minutes must be negative or zero.
-     *  If the hours is zero, the minutes may be positive, negative or zero.
-     * @param hours the time-zone offset in hours, from -18 to +18
-     * @param minutes the time-zone offset in minutes, from 0 to &plusmn;59, sign matches hours
-     * @return the zone-offset, not null
-     * @throws DateTimeException if the offset is not in the required range
-     */
-    ofHoursMinutes(hours: number, minutes: number): ZoneOffset;
-
-    /**
-     * Obtains an instance of {@code ZoneOffset} using an offset in
-     *  hours, minutes and seconds.
-     *  <p>
-     *  The sign of the hours, minutes and seconds components must match.
-     *  Thus, if the hours is negative, the minutes and seconds must be negative or zero.
-     * @param hours the time-zone offset in hours, from -18 to +18
-     * @param minutes the time-zone offset in minutes, from 0 to &plusmn;59, sign matches hours and seconds
-     * @param seconds the time-zone offset in seconds, from 0 to &plusmn;59, sign matches hours and minutes
-     * @return the zone-offset, not null
-     * @throws DateTimeException if the offset is not in the required range
-     */
-    ofHoursMinutesSeconds(
-      hours: number,
-      minutes: number,
-      seconds: number
-    ): ZoneOffset;
-
-    /**
-     * Obtains an instance of {@code ZoneOffset} from a temporal object.
-     *  <p>
-     *  This obtains an offset 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 ZoneOffset}.
-     *  <p>
-     *  A {@code TemporalAccessor} represents some form of date and time information.
-     *  This factory converts the arbitrary temporal object to an instance of {@code ZoneOffset}.
-     *  <p>
-     *  The conversion uses the {@link TemporalQueries#offset()} query, which relies
-     *  on extracting the {@link ChronoField#OFFSET_SECONDS OFFSET_SECONDS} field.
-     *  <p>
-     *  This method matches the signature of the functional interface {@link TemporalQuery}
-     *  allowing it to be used as a query via method reference, {@code ZoneOffset::from}.
-     * @param temporal the temporal object to convert, not null
-     * @return the zone-offset, not null
-     * @throws DateTimeException if unable to convert to an {@code ZoneOffset}
-     */
-    from(temporal: TemporalAccessor): ZoneOffset;
-
-    /**
-     * Obtains an instance of {@code ZoneOffset} specifying the total offset in seconds
-     *  <p>
-     *  The offset must be in the range {@code -18:00} to {@code +18:00}, which corresponds to -64800 to +64800.
-     * @param totalSeconds the total time-zone offset in seconds, from -64800 to +64800
-     * @return the ZoneOffset, not null
-     * @throws DateTimeException if the offset is not in the required range
-     */
-    ofTotalSeconds(totalSeconds: number): ZoneOffset;
-
     /**
      * Gets the total zone offset in seconds.
      *  <p>

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

@@ -5,12 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var _default = {
-  of: function of() {},
-  ofHours: function ofHours() {},
-  ofHoursMinutes: function ofHoursMinutes() {},
-  ofHoursMinutesSeconds: function ofHoursMinutesSeconds() {},
-  from: function from() {},
-  ofTotalSeconds: function ofTotalSeconds() {},
   getTotalSeconds: function getTotalSeconds() {},
   getId: function getId() {},
   getRules: function getRules() {},

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() {},