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

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

@@ -1,11 +1,9 @@
-import type { TemporalAmount } from "../temporal/TemporalAmount";
-import type { CharSequence } from "../../lang/CharSequence";
-import type { LocalDate } from "../LocalDate";
 import type { TemporalUnit } from "../temporal/TemporalUnit";
 
 import type { List } from "../../util/List";
 import type { IsoChronology } from "../chrono/IsoChronology";
 
+import type { TemporalAmount } from "../temporal/TemporalAmount";
 import type { Temporal } from "../temporal/Temporal";
 import type { Object } from "../../lang/Object";
 import type { String } from "../../lang/String";
@@ -54,138 +52,6 @@ import type { Serializable } from "../../io/Serializable";
 export type Period = Object &
   ChronoPeriod &
   Serializable & {
-    /**
-     * Obtains a {@code Period} representing a number of years.
-     *  <p>
-     *  The resulting period will have the specified years.
-     *  The months and days units will be zero.
-     * @param years the number of years, positive or negative
-     * @return the period of years, not null
-     */
-    ofYears(years: number): Period;
-
-    /**
-     * Obtains a {@code Period} representing a number of months.
-     *  <p>
-     *  The resulting period will have the specified months.
-     *  The years and days units will be zero.
-     * @param months the number of months, positive or negative
-     * @return the period of months, not null
-     */
-    ofMonths(months: number): Period;
-
-    /**
-     * Obtains a {@code Period} representing a number of weeks.
-     *  <p>
-     *  The resulting period will be day-based, with the amount of days
-     *  equal to the number of weeks multiplied by 7.
-     *  The years and months units will be zero.
-     * @param weeks the number of weeks, positive or negative
-     * @return the period, with the input weeks converted to days, not null
-     */
-    ofWeeks(weeks: number): Period;
-
-    /**
-     * Obtains a {@code Period} representing a number of days.
-     *  <p>
-     *  The resulting period will have the specified days.
-     *  The years and months units will be zero.
-     * @param days the number of days, positive or negative
-     * @return the period of days, not null
-     */
-    ofDays(days: number): Period;
-
-    /**
-     * Obtains a {@code Period} representing a number of years, months and days.
-     *  <p>
-     *  This creates an instance based on years, months and days.
-     * @param years the amount of years, may be negative
-     * @param months the amount of months, may be negative
-     * @param days the amount of days, may be negative
-     * @return the period of years, months and days, not null
-     */
-    of(years: number, months: number, days: number): Period;
-
-    /**
-     * Obtains an instance of {@code Period} from a temporal amount.
-     *  <p>
-     *  This obtains a period based on the specified amount.
-     *  A {@code TemporalAmount} represents an  amount of time, which may be
-     *  date-based or time-based, which this factory extracts to a {@code Period}.
-     *  <p>
-     *  The conversion loops around the set of units from the amount and uses
-     *  the {@link ChronoUnit#YEARS YEARS}, {@link ChronoUnit#MONTHS MONTHS}
-     *  and {@link ChronoUnit#DAYS DAYS} units to create a period.
-     *  If any other units are found then an exception is thrown.
-     *  <p>
-     *  If the amount is a {@code ChronoPeriod} then it must use the ISO chronology.
-     * @param amount the temporal amount to convert, not null
-     * @return the equivalent period, not null
-     * @throws DateTimeException if unable to convert to a {@code Period}
-     * @throws ArithmeticException if the amount of years, months or days exceeds an int
-     */
-    from(amount: TemporalAmount): Period;
-
-    /**
-     * Obtains a {@code Period} from a text string such as {@code PnYnMnD}.
-     *  <p>
-     *  This will parse the string produced by {@code toString()} which is
-     *  based on the ISO-8601 period formats {@code PnYnMnD} and {@code PnW}.
-     *  <p>
-     *  The string starts with an optional sign, denoted by the ASCII negative
-     *  or positive symbol. If negative, the whole period is negated.
-     *  The ASCII letter "P" is next in upper or lower case.
-     *  There are then four sections, each consisting of a number and a suffix.
-     *  At least one of the four sections must be present.
-     *  The sections have suffixes in ASCII of "Y", "M", "W" and "D" for
-     *  years, months, weeks and days, accepted in upper or lower case.
-     *  The suffixes must occur in order.
-     *  The number part of each section must consist of ASCII digits.
-     *  The number may be prefixed by the ASCII negative or positive symbol.
-     *  The number must parse to an {@code int}.
-     *  <p>
-     *  The leading plus/minus sign, and negative values for other units are
-     *  not part of the ISO-8601 standard. In addition, ISO-8601 does not
-     *  permit mixing between the {@code PnYnMnD} and {@code PnW} formats.
-     *  Any week-based input is multiplied by 7 and treated as a number of days.
-     *  <p>
-     *  For example, the following are valid inputs:
-     *  <pre>
-     *    "P2Y"             -- Period.ofYears(2)
-     *    "P3M"             -- Period.ofMonths(3)
-     *    "P4W"             -- Period.ofWeeks(4)
-     *    "P5D"             -- Period.ofDays(5)
-     *    "P1Y2M3D"         -- Period.of(1, 2, 3)
-     *    "P1Y2M3W4D"       -- Period.of(1, 2, 25)
-     *    "P-1Y2M"          -- Period.of(-1, 2, 0)
-     *    "-P1Y2M"          -- Period.of(-1, -2, 0)
-     *  </pre>
-     * @param text the text to parse, not null
-     * @return the parsed period, not null
-     * @throws DateTimeParseException if the text cannot be parsed to a period
-     */
-    parse(text: CharSequence): Period;
-
-    /**
-     * Obtains a {@code Period} consisting of the number of years, months,
-     *  and days between two dates.
-     *  <p>
-     *  The start date is included, but the end date is not.
-     *  The period is calculated by removing complete months, then calculating
-     *  the remaining number of days, adjusting to ensure that both have the same sign.
-     *  The number of months is then split into years and months based on a 12 month year.
-     *  A month is considered if the end day-of-month is greater than or equal to the start day-of-month.
-     *  For example, from {@code 2010-01-15} to {@code 2011-03-18} is one year, two months and three days.
-     *  <p>
-     *  The result of this method can be a negative period if the end is before the start.
-     *  The negative sign will be the same in each of year, month and day.
-     * @param startDateInclusive the start date, inclusive, not null
-     * @param endDateExclusive the end date, exclusive, not null
-     * @return the period between this date and the end date, not null
-     * @see ChronoLocalDate#until(ChronoLocalDate)
-     */
-    between(startDateInclusive: LocalDate, endDateExclusive: LocalDate): Period;
-
     /**
      * Gets the value of the requested unit.
      *  <p>

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

@@ -5,14 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var _default = {
-  ofYears: function ofYears() {},
-  ofMonths: function ofMonths() {},
-  ofWeeks: function ofWeeks() {},
-  ofDays: function ofDays() {},
-  of: function of() {},
-  from: function from() {},
-  parse: function parse() {},
-  between: function between() {},
   get: function get() {},
   getUnits: function getUnits() {},
   getChronology: function getChronology() {},

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