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

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

@@ -1,30 +1,25 @@
-import type { Comparator } from "../../util/Comparator";
-import type { ZoneId } from "../ZoneId";
-import type { Clock } from "../Clock";
-import type { LocalDate } from "../LocalDate";
-import type { LocalTime } from "../LocalTime";
-import type { ZoneOffset } from "../ZoneOffset";
-import type { LocalDateTime } from "../LocalDateTime";
-
-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 { 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 { ZoneId } from "../ZoneId";
 import type { ZonedDateTime } from "../ZonedDateTime";
 import type { OffsetTime } from "../OffsetTime";
+import type { Instant } from "../Instant";
 import type { Object } from "../../lang/Object";
 import type { Comparable } from "../../lang/Comparable";
 import type { Serializable } from "../../io/Serializable";
@@ -63,171 +58,6 @@ export type OffsetDateTime = Object &
   TemporalAdjuster &
   Comparable &
   Serializable & {
-    /**
-     * Gets a comparator that compares two {@code OffsetDateTime} instances
-     *  based solely on the instant.
-     *  <p>
-     *  This method differs from the comparison in {@link #compareTo} in that it
-     *  only compares the underlying instant.
-     * @return a comparator that compares in time-line order
-     * @see #isAfter
-     * @see #isBefore
-     * @see #isEqual
-     */
-    timeLineOrder(): Comparator;
-
-    /**
-     * 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 offset will be calculated from 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(): OffsetDateTime;
-
-    /**
-     * 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): OffsetDateTime;
-
-    /**
-     * Obtains the current date-time from the specified clock.
-     *  <p>
-     *  This will query the specified clock to obtain the current date-time.
-     *  The offset will be calculated from 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): OffsetDateTime;
-
-    /**
-     * Obtains an instance of {@code OffsetDateTime} from a date, time and offset.
-     *  <p>
-     *  This creates an offset date-time with the specified local date, time and offset.
-     * @param date the local date, not null
-     * @param time the local time, not null
-     * @param offset the zone offset, not null
-     * @return the offset date-time, not null
-     */
-    of(date: LocalDate, time: LocalTime, offset: ZoneOffset): OffsetDateTime;
-
-    /**
-     * Obtains an instance of {@code OffsetDateTime} from a date-time and offset.
-     *  <p>
-     *  This creates an offset date-time with the specified local date-time and offset.
-     * @param dateTime the local date-time, not null
-     * @param offset the zone offset, not null
-     * @return the offset date-time, not null
-     */
-    of(dateTime: LocalDateTime, offset: ZoneOffset): OffsetDateTime;
-
-    /**
-     * Obtains an instance of {@code OffsetDateTime} from a year, month, day,
-     *  hour, minute, second, nanosecond and offset.
-     *  <p>
-     *  This creates an offset date-time with the seven specified fields.
-     *  <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 offset the zone offset, 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,
-      offset: ZoneOffset
-    ): OffsetDateTime;
-
-    /**
-     * Obtains an instance of {@code OffsetDateTime} from an {@code Instant} and zone ID.
-     *  <p>
-     *  This creates an offset date-time with the same instant as that specified.
-     *  Finding the offset from UTC/Greenwich 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, which may be an offset, not null
-     * @return the offset date-time, not null
-     * @throws DateTimeException if the result exceeds the supported range
-     */
-    ofInstant(instant: Instant, zone: ZoneId): OffsetDateTime;
-
-    /**
-     * Obtains an instance of {@code OffsetDateTime} from a temporal object.
-     *  <p>
-     *  This obtains an offset 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 OffsetDateTime}.
-     *  <p>
-     *  The conversion will first obtain a {@code ZoneOffset} from the temporal object.
-     *  It will then try to obtain a {@code LocalDateTime}, falling back to an {@code Instant} if necessary.
-     *  The result will be the combination of {@code ZoneOffset} with either
-     *  with {@code LocalDateTime} or {@code Instant}.
-     *  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 OffsetDateTime::from}.
-     * @param temporal the temporal object to convert, not null
-     * @return the offset date-time, not null
-     * @throws DateTimeException if unable to convert to an {@code OffsetDateTime}
-     */
-    from(temporal: TemporalAccessor): OffsetDateTime;
-
-    /**
-     * Obtains an instance of {@code OffsetDateTime} from a text string
-     *  such as {@code 2007-12-03T10:15:30+01:00}.
-     *  <p>
-     *  The string must represent a valid date-time and is parsed using
-     *  {@link java.time.format.DateTimeFormatter#ISO_OFFSET_DATE_TIME}.
-     * @param text the text to parse such as "2007-12-03T10:15:30+01:00", not null
-     * @return the parsed offset date-time, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence): OffsetDateTime;
-
-    /**
-     * Obtains an instance of {@code OffsetDateTime} 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 offset date-time, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence, formatter: DateTimeFormatter): OffsetDateTime;
-
     /**
      * Checks if the specified field is supported.
      *  <p>

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

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

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

@@ -1,22 +1,16 @@
-import type { ZoneId } from "../ZoneId";
-import type { Clock } from "../Clock";
-import type { LocalTime } from "../LocalTime";
-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 { 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 { LocalDate } from "../LocalDate";
 import type { OffsetDateTime } from "../OffsetDateTime";
@@ -49,138 +43,6 @@ export type OffsetTime = Object &
   TemporalAdjuster &
   Comparable &
   Serializable & {
-    /**
-     * Obtains the current 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 time.
-     *  The offset will be calculated from 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 time using the system clock and default time-zone, not null
-     */
-    now(): OffsetTime;
-
-    /**
-     * Obtains the current 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 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 time using the system clock, not null
-     */
-    now(zone: ZoneId): OffsetTime;
-
-    /**
-     * Obtains the current time from the specified clock.
-     *  <p>
-     *  This will query the specified clock to obtain the current time.
-     *  The offset will be calculated from 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 time, not null
-     */
-    now(clock: Clock): OffsetTime;
-
-    /**
-     * Obtains an instance of {@code OffsetTime} from a local time and an offset.
-     * @param time the local time, not null
-     * @param offset the zone offset, not null
-     * @return the offset time, not null
-     */
-    of(time: LocalTime, offset: ZoneOffset): OffsetTime;
-
-    /**
-     * Obtains an instance of {@code OffsetTime} from an hour, minute, second and nanosecond.
-     *  <p>
-     *  This creates an offset time with the four specified fields.
-     *  <p>
-     *  This method exists primarily for writing test cases.
-     *  Non test-code will typically use other methods to create an offset time.
-     *  {@code LocalTime} has two additional convenience variants of the
-     *  equivalent factory method taking fewer arguments.
-     *  They are not provided here to reduce the footprint of the API.
-     * @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 offset the zone offset, not null
-     * @return the offset time, not null
-     * @throws DateTimeException if the value of any field is out of range
-     */
-    of(
-      hour: number,
-      minute: number,
-      second: number,
-      nanoOfSecond: number,
-      offset: ZoneOffset
-    ): OffsetTime;
-
-    /**
-     * Obtains an instance of {@code OffsetTime} from an {@code Instant} and zone ID.
-     *  <p>
-     *  This creates an offset time with the same instant as that specified.
-     *  Finding the offset from UTC/Greenwich is simple as there is only one valid
-     *  offset for each instant.
-     *  <p>
-     *  The date component of the instant is dropped during the conversion.
-     *  This means that the conversion can never fail due to the instant being
-     *  out of the valid range of dates.
-     * @param instant the instant to create the time from, not null
-     * @param zone the time-zone, which may be an offset, not null
-     * @return the offset time, not null
-     */
-    ofInstant(instant: Instant, zone: ZoneId): OffsetTime;
-
-    /**
-     * Obtains an instance of {@code OffsetTime} from a temporal object.
-     *  <p>
-     *  This obtains an offset 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 OffsetTime}.
-     *  <p>
-     *  The conversion extracts and combines the {@code ZoneOffset} and the
-     *  {@code LocalTime} from the temporal object.
-     *  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 OffsetTime::from}.
-     * @param temporal the temporal object to convert, not null
-     * @return the offset time, not null
-     * @throws DateTimeException if unable to convert to an {@code OffsetTime}
-     */
-    from(temporal: TemporalAccessor): OffsetTime;
-
-    /**
-     * Obtains an instance of {@code OffsetTime} from a text string such as {@code 10:15:30+01:00}.
-     *  <p>
-     *  The string must represent a valid time and is parsed using
-     *  {@link java.time.format.DateTimeFormatter#ISO_OFFSET_TIME}.
-     * @param text the text to parse such as "10:15:30+01:00", not null
-     * @return the parsed local time, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence): OffsetTime;
-
-    /**
-     * Obtains an instance of {@code OffsetTime} from a text string using a specific formatter.
-     *  <p>
-     *  The text is parsed using the formatter, returning a time.
-     * @param text the text to parse, not null
-     * @param formatter the formatter to use, not null
-     * @return the parsed offset time, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence, formatter: DateTimeFormatter): OffsetTime;
-
     /**
      * Checks if the specified field is supported.
      *  <p>

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

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

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