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

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

@@ -5,14 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var _default = {
-  systemUTC: function systemUTC() {},
-  systemDefaultZone: function systemDefaultZone() {},
-  system: function system() {},
-  tickSeconds: function tickSeconds() {},
-  tickMinutes: function tickMinutes() {},
-  tick: function tick() {},
-  fixed: function fixed() {},
-  offset: function offset() {},
   getZone: function getZone() {},
   withZone: function withZone() {},
   millis: function millis() {},

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

@@ -1,11 +1,11 @@
 import type { TemporalUnit } from "../temporal/TemporalUnit";
-import type { TemporalAmount } from "../temporal/TemporalAmount";
-import type { CharSequence } from "../../lang/CharSequence";
-import type { Temporal } from "../temporal/Temporal";
+
 import type { List } from "../../util/List";
 
+import type { Temporal } from "../temporal/Temporal";
 import type { Object } from "../../lang/Object";
 import type { String } from "../../lang/String";
+import type { TemporalAmount } from "../temporal/TemporalAmount";
 import type { Comparable } from "../../lang/Comparable";
 import type { Serializable } from "../../io/Serializable";
 
@@ -47,196 +47,6 @@ export type Duration = Object &
   TemporalAmount &
   Comparable &
   Serializable & {
-    /**
-     * Obtains a {@code Duration} representing a number of standard 24 hour days.
-     *  <p>
-     *  The seconds are calculated based on the standard definition of a day,
-     *  where each day is 86400 seconds which implies a 24 hour day.
-     *  The nanosecond in second field is set to zero.
-     * @param days the number of days, positive or negative
-     * @return a {@code Duration}, not null
-     * @throws ArithmeticException if the input days exceeds the capacity of {@code Duration}
-     */
-    ofDays(days: number): Duration;
-
-    /**
-     * Obtains a {@code Duration} representing a number of standard hours.
-     *  <p>
-     *  The seconds are calculated based on the standard definition of an hour,
-     *  where each hour is 3600 seconds.
-     *  The nanosecond in second field is set to zero.
-     * @param hours the number of hours, positive or negative
-     * @return a {@code Duration}, not null
-     * @throws ArithmeticException if the input hours exceeds the capacity of {@code Duration}
-     */
-    ofHours(hours: number): Duration;
-
-    /**
-     * Obtains a {@code Duration} representing a number of standard minutes.
-     *  <p>
-     *  The seconds are calculated based on the standard definition of a minute,
-     *  where each minute is 60 seconds.
-     *  The nanosecond in second field is set to zero.
-     * @param minutes the number of minutes, positive or negative
-     * @return a {@code Duration}, not null
-     * @throws ArithmeticException if the input minutes exceeds the capacity of {@code Duration}
-     */
-    ofMinutes(minutes: number): Duration;
-
-    /**
-     * Obtains a {@code Duration} representing a number of seconds.
-     *  <p>
-     *  The nanosecond in second field is set to zero.
-     * @param seconds the number of seconds, positive or negative
-     * @return a {@code Duration}, not null
-     */
-    ofSeconds(seconds: number): Duration;
-
-    /**
-     * Obtains a {@code Duration} representing a number of seconds and an
-     *  adjustment in nanoseconds.
-     *  <p>
-     *  This method allows an arbitrary number of nanoseconds to be passed in.
-     *  The factory will alter the values of the second and nanosecond in order
-     *  to ensure that the stored nanosecond is in the range 0 to 999,999,999.
-     *  For example, the following will result in the exactly the same duration:
-     *  <pre>
-     *   Duration.ofSeconds(3, 1);
-     *   Duration.ofSeconds(4, -999_999_999);
-     *   Duration.ofSeconds(2, 1000_000_001);
-     *  </pre>
-     * @param seconds the number of seconds, positive or negative
-     * @param nanoAdjustment the nanosecond adjustment to the number of seconds, positive or negative
-     * @return a {@code Duration}, not null
-     * @throws ArithmeticException if the adjustment causes the seconds to exceed the capacity of {@code Duration}
-     */
-    ofSeconds(seconds: number, nanoAdjustment: number): Duration;
-
-    /**
-     * Obtains a {@code Duration} representing a number of milliseconds.
-     *  <p>
-     *  The seconds and nanoseconds are extracted from the specified milliseconds.
-     * @param millis the number of milliseconds, positive or negative
-     * @return a {@code Duration}, not null
-     */
-    ofMillis(millis: number): Duration;
-
-    /**
-     * Obtains a {@code Duration} representing a number of nanoseconds.
-     *  <p>
-     *  The seconds and nanoseconds are extracted from the specified nanoseconds.
-     * @param nanos the number of nanoseconds, positive or negative
-     * @return a {@code Duration}, not null
-     */
-    ofNanos(nanos: number): Duration;
-
-    /**
-     * Obtains a {@code Duration} representing an amount in the specified unit.
-     *  <p>
-     *  The parameters represent the two parts of a phrase like '6 Hours'. For example:
-     *  <pre>
-     *   Duration.of(3, SECONDS);
-     *   Duration.of(465, HOURS);
-     *  </pre>
-     *  Only a subset of units are accepted by this method.
-     *  The unit must either have an {@linkplain TemporalUnit#isDurationEstimated() exact duration} or
-     *  be {@link ChronoUnit#DAYS} which is treated as 24 hours. Other units throw an exception.
-     * @param amount the amount of the duration, measured in terms of the unit, positive or negative
-     * @param unit the unit that the duration is measured in, must have an exact duration, not null
-     * @return a {@code Duration}, not null
-     * @throws DateTimeException if the period unit has an estimated duration
-     * @throws ArithmeticException if a numeric overflow occurs
-     */
-    of(amount: number, unit: TemporalUnit): Duration;
-
-    /**
-     * Obtains an instance of {@code Duration} from a temporal amount.
-     *  <p>
-     *  This obtains a duration 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 duration.
-     *  <p>
-     *  The conversion loops around the set of units from the amount and uses
-     *  the {@linkplain TemporalUnit#getDuration() duration} of the unit to
-     *  calculate the total {@code Duration}.
-     *  Only a subset of units are accepted by this method. The unit must either
-     *  have an {@linkplain TemporalUnit#isDurationEstimated() exact duration}
-     *  or be {@link ChronoUnit#DAYS} which is treated as 24 hours.
-     *  If any other units are found then an exception is thrown.
-     * @param amount the temporal amount to convert, not null
-     * @return the equivalent duration, not null
-     * @throws DateTimeException if unable to convert to a {@code Duration}
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    from(amount: TemporalAmount): Duration;
-
-    /**
-     * Obtains a {@code Duration} from a text string such as {@code PnDTnHnMn.nS}.
-     *  <p>
-     *  This will parse a textual representation of a duration, including the
-     *  string produced by {@code toString()}. The formats accepted are based
-     *  on the ISO-8601 duration format {@code PnDTnHnMn.nS} with days
-     *  considered to be exactly 24 hours.
-     *  <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.
-     *  The sections have suffixes in ASCII of "D", "H", "M" and "S" for
-     *  days, hours, minutes and seconds, accepted in upper or lower case.
-     *  The suffixes must occur in order. The ASCII letter "T" must occur before
-     *  the first occurrence, if any, of an hour, minute or second section.
-     *  At least one of the four sections must be present, and if "T" is present
-     *  there must be at least one section after the "T".
-     *  The number part of each section must consist of one or more ASCII digits.
-     *  The number may be prefixed by the ASCII negative or positive symbol.
-     *  The number of days, hours and minutes must parse to an {@code long}.
-     *  The number of seconds must parse to an {@code long} with optional fraction.
-     *  The decimal point may be either a dot or a comma.
-     *  The fractional part may have from zero to 9 digits.
-     *  <p>
-     *  The leading plus/minus sign, and negative values for other units are
-     *  not part of the ISO-8601 standard.
-     *  <p>
-     *  Examples:
-     *  <pre>
-     *     "PT20.345S" -- parses as "20.345 seconds"
-     *     "PT15M"     -- parses as "15 minutes" (where a minute is 60 seconds)
-     *     "PT10H"     -- parses as "10 hours" (where an hour is 3600 seconds)
-     *     "P2D"       -- parses as "2 days" (where a day is 24 hours or 86400 seconds)
-     *     "P2DT3H4M"  -- parses as "2 days, 3 hours and 4 minutes"
-     *     "P-6H3M"    -- parses as "-6 hours and +3 minutes"
-     *     "-P6H3M"    -- parses as "-6 hours and -3 minutes"
-     *     "-P-6H+3M"  -- parses as "+6 hours and -3 minutes"
-     *  </pre>
-     * @param text the text to parse, not null
-     * @return the parsed duration, not null
-     * @throws DateTimeParseException if the text cannot be parsed to a duration
-     */
-    parse(text: CharSequence): Duration;
-
-    /**
-     * Obtains a {@code Duration} representing the duration between two temporal objects.
-     *  <p>
-     *  This calculates the duration between two temporal objects. If the objects
-     *  are of different types, then the duration is calculated based on the type
-     *  of the first object. For example, if the first argument is a {@code LocalTime}
-     *  then the second argument is converted to a {@code LocalTime}.
-     *  <p>
-     *  The specified temporal objects must support the {@link ChronoUnit#SECONDS SECONDS} unit.
-     *  For full accuracy, either the {@link ChronoUnit#NANOS NANOS} unit or the
-     *  {@link ChronoField#NANO_OF_SECOND NANO_OF_SECOND} field should be supported.
-     *  <p>
-     *  The result of this method can be a negative period if the end is before the start.
-     *  To guarantee to obtain a positive duration call {@link #abs()} on the result.
-     * @param startInclusive the start instant, inclusive, not null
-     * @param endExclusive the end instant, exclusive, not null
-     * @return a {@code Duration}, not null
-     * @throws DateTimeException if the seconds between the temporals cannot be obtained
-     * @throws ArithmeticException if the calculation exceeds the capacity of {@code Duration}
-     */
-    between(startInclusive: Temporal, endExclusive: Temporal): Duration;
-
     /**
      * Gets the value of the requested unit.
      *  <p>

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

@@ -5,16 +5,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports["default"] = void 0;
 var _default = {
-  ofDays: function ofDays() {},
-  ofHours: function ofHours() {},
-  ofMinutes: function ofMinutes() {},
-  ofSeconds: function ofSeconds() {},
-  ofMillis: function ofMillis() {},
-  ofNanos: function ofNanos() {},
-  of: function of() {},
-  from: function from() {},
-  parse: function parse() {},
-  between: function between() {},
   get: function get() {},
   getUnits: function getUnits() {},
   isZero: function isZero() {},

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

@@ -1,7 +1,3 @@
-import type { Clock } from "../Clock";
-
-import type { TemporalAccessor } from "../temporal/TemporalAccessor";
-import type { CharSequence } from "../../lang/CharSequence";
 import type { TemporalField } from "../temporal/TemporalField";
 
 import type { TemporalUnit } from "../temporal/TemporalUnit";
@@ -133,103 +129,6 @@ export type Instant = Object &
   TemporalAdjuster &
   Comparable &
   Serializable & {
-    /**
-     * Obtains the current instant from the system clock.
-     *  <p>
-     *  This will query the {@link Clock#systemUTC() system UTC clock} to
-     *  obtain the current instant.
-     *  <p>
-     *  Using this method will prevent the ability to use an alternate time-source for
-     *  testing because the clock is effectively hard-coded.
-     * @return the current instant using the system clock, not null
-     */
-    now(): Instant;
-
-    /**
-     * Obtains the current instant from the specified clock.
-     *  <p>
-     *  This will query the specified clock to obtain the current time.
-     *  <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 instant, not null
-     */
-    now(clock: Clock): Instant;
-
-    /**
-     * Obtains an instance of {@code Instant} using seconds from the
-     *  epoch of 1970-01-01T00:00:00Z.
-     *  <p>
-     *  The nanosecond field is set to zero.
-     * @param epochSecond the number of seconds from 1970-01-01T00:00:00Z
-     * @return an instant, not null
-     * @throws DateTimeException if the instant exceeds the maximum or minimum instant
-     */
-    ofEpochSecond(epochSecond: number): Instant;
-
-    /**
-     * Obtains an instance of {@code Instant} using seconds from the
-     *  epoch of 1970-01-01T00:00:00Z and nanosecond fraction of second.
-     *  <p>
-     *  This method allows an arbitrary number of nanoseconds to be passed in.
-     *  The factory will alter the values of the second and nanosecond in order
-     *  to ensure that the stored nanosecond is in the range 0 to 999,999,999.
-     *  For example, the following will result in the exactly the same instant:
-     *  <pre>
-     *   Instant.ofEpochSecond(3, 1);
-     *   Instant.ofEpochSecond(4, -999_999_999);
-     *   Instant.ofEpochSecond(2, 1000_000_001);
-     *  </pre>
-     * @param epochSecond the number of seconds from 1970-01-01T00:00:00Z
-     * @param nanoAdjustment the nanosecond adjustment to the number of seconds, positive or negative
-     * @return an instant, not null
-     * @throws DateTimeException if the instant exceeds the maximum or minimum instant
-     * @throws ArithmeticException if numeric overflow occurs
-     */
-    ofEpochSecond(epochSecond: number, nanoAdjustment: number): Instant;
-
-    /**
-     * Obtains an instance of {@code Instant} using milliseconds from the
-     *  epoch of 1970-01-01T00:00:00Z.
-     *  <p>
-     *  The seconds and nanoseconds are extracted from the specified milliseconds.
-     * @param epochMilli the number of milliseconds from 1970-01-01T00:00:00Z
-     * @return an instant, not null
-     * @throws DateTimeException if the instant exceeds the maximum or minimum instant
-     */
-    ofEpochMilli(epochMilli: number): Instant;
-
-    /**
-     * Obtains an instance of {@code Instant} from a temporal object.
-     *  <p>
-     *  This obtains an instant 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 Instant}.
-     *  <p>
-     *  The conversion extracts the {@link ChronoField#INSTANT_SECONDS INSTANT_SECONDS}
-     *  and {@link ChronoField#NANO_OF_SECOND NANO_OF_SECOND} fields.
-     *  <p>
-     *  This method matches the signature of the functional interface {@link TemporalQuery}
-     *  allowing it to be used as a query via method reference, {@code Instant::from}.
-     * @param temporal the temporal object to convert, not null
-     * @return the instant, not null
-     * @throws DateTimeException if unable to convert to an {@code Instant}
-     */
-    from(temporal: TemporalAccessor): Instant;
-
-    /**
-     * Obtains an instance of {@code Instant} from a text string such as
-     *  {@code 2007-12-03T10:15:30.00Z}.
-     *  <p>
-     *  The string must represent a valid instant in UTC and is parsed using
-     *  {@link DateTimeFormatter#ISO_INSTANT}.
-     * @param text the text to parse, not null
-     * @return the parsed instant, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence): Instant;
-
     /**
      * Checks if the specified field is supported.
      *  <p>

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

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

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

@@ -1,17 +1,11 @@
-import type { ZoneId } from "../ZoneId";
-import type { Clock } from "../Clock";
-
-import type { Month } from "../Month";
-
-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 { IsoChronology } from "../chrono/IsoChronology";
 import type { Era } from "../chrono/Era";
+import type { Month } from "../Month";
 import type { DayOfWeek } from "../DayOfWeek";
 import type { TemporalAdjuster } from "../temporal/TemporalAdjuster";
 import type { TemporalAmount } from "../temporal/TemporalAmount";
@@ -20,11 +14,13 @@ import type { TemporalQuery } from "../temporal/TemporalQuery";
 import type { Temporal } from "../temporal/Temporal";
 import type { ChronoLocalDate } from "../chrono/ChronoLocalDate";
 import type { Period } from "../Period";
+import type { DateTimeFormatter } from "../format/DateTimeFormatter";
 import type { String } from "../../lang/String";
 import type { LocalTime } from "../LocalTime";
 import type { LocalDateTime } from "../LocalDateTime";
 import type { OffsetTime } from "../OffsetTime";
 import type { OffsetDateTime } from "../OffsetDateTime";
+import type { ZoneId } from "../ZoneId";
 import type { ZonedDateTime } from "../ZonedDateTime";
 import type { Object } from "../../lang/Object";
 import type { Serializable } from "../../io/Serializable";
@@ -64,132 +60,6 @@ export type LocalDate = Object &
   TemporalAdjuster &
   ChronoLocalDate &
   Serializable & {
-    /**
-     * Obtains the current date from the system clock in the default time-zone.
-     *  <p>
-     *  This will query the {@link Clock#systemDefaultZone() system clock} in the default
-     *  time-zone to obtain the current date.
-     *  <p>
-     *  Using this method will prevent the ability to use an alternate clock for testing
-     *  because the clock is hard-coded.
-     * @return the current date using the system clock and default time-zone, not null
-     */
-    now(): LocalDate;
-
-    /**
-     * Obtains the current date from the system clock in the specified time-zone.
-     *  <p>
-     *  This will query the {@link Clock#system(ZoneId) system clock} to obtain the current date.
-     *  Specifying the time-zone avoids dependence on the default time-zone.
-     *  <p>
-     *  Using this method will prevent the ability to use an alternate clock for testing
-     *  because the clock is hard-coded.
-     * @param zone the zone ID to use, not null
-     * @return the current date using the system clock, not null
-     */
-    now(zone: ZoneId): LocalDate;
-
-    /**
-     * Obtains the current date from the specified clock.
-     *  <p>
-     *  This will query the specified clock to obtain the current date - today.
-     *  Using this method allows the use of an alternate clock for testing.
-     *  The alternate clock may be introduced using {@link Clock dependency injection}.
-     * @param clock the clock to use, not null
-     * @return the current date, not null
-     */
-    now(clock: Clock): LocalDate;
-
-    /**
-     * Obtains an instance of {@code LocalDate} from a year, month and day.
-     *  <p>
-     *  This returns a {@code LocalDate} with the specified year, month and day-of-month.
-     *  The day must be valid for the year and month, otherwise an exception will be thrown.
-     * @param year the year to represent, from MIN_YEAR to MAX_YEAR
-     * @param month the month-of-year to represent, not null
-     * @param dayOfMonth the day-of-month to represent, from 1 to 31
-     * @return the local date, not null
-     * @throws DateTimeException if the value of any field is out of range,&#xA; or if the day-of-month is invalid for the month-year
-     */
-    of(year: number, month: Month, dayOfMonth: number): LocalDate;
-
-    /**
-     * Obtains an instance of {@code LocalDate} from a year, month and day.
-     *  <p>
-     *  This returns a {@code LocalDate} with the specified year, month and day-of-month.
-     *  The day must be valid for the year and month, otherwise an exception will be thrown.
-     * @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
-     * @return the local date, not null
-     * @throws DateTimeException if the value of any field is out of range,&#xA; or if the day-of-month is invalid for the month-year
-     */
-    of(year: number, month: number, dayOfMonth: number): LocalDate;
-
-    /**
-     * Obtains an instance of {@code LocalDate} from a year and day-of-year.
-     *  <p>
-     *  This returns a {@code LocalDate} with the specified year and day-of-year.
-     *  The day-of-year must be valid for the year, otherwise an exception will be thrown.
-     * @param year the year to represent, from MIN_YEAR to MAX_YEAR
-     * @param dayOfYear the day-of-year to represent, from 1 to 366
-     * @return the local date, not null
-     * @throws DateTimeException if the value of any field is out of range,&#xA; or if the day-of-year is invalid for the year
-     */
-    ofYearDay(year: number, dayOfYear: number): LocalDate;
-
-    /**
-     * Obtains an instance of {@code LocalDate} from the epoch day count.
-     *  <p>
-     *  This returns a {@code LocalDate} with the specified epoch-day.
-     *  The {@link ChronoField#EPOCH_DAY EPOCH_DAY} is a simple incrementing count
-     *  of days where day 0 is 1970-01-01. Negative numbers represent earlier days.
-     * @param epochDay the Epoch Day to convert, based on the epoch 1970-01-01
-     * @return the local date, not null
-     * @throws DateTimeException if the epoch day exceeds the supported date range
-     */
-    ofEpochDay(epochDay: number): LocalDate;
-
-    /**
-     * Obtains an instance of {@code LocalDate} from a temporal object.
-     *  <p>
-     *  This obtains a local date 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 LocalDate}.
-     *  <p>
-     *  The conversion uses the {@link TemporalQueries#localDate()} query, which relies
-     *  on extracting the {@link ChronoField#EPOCH_DAY EPOCH_DAY} 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 LocalDate::from}.
-     * @param temporal the temporal object to convert, not null
-     * @return the local date, not null
-     * @throws DateTimeException if unable to convert to a {@code LocalDate}
-     */
-    from(temporal: TemporalAccessor): LocalDate;
-
-    /**
-     * Obtains an instance of {@code LocalDate} from a text string such as {@code 2007-12-03}.
-     *  <p>
-     *  The string must represent a valid date and is parsed using
-     *  {@link java.time.format.DateTimeFormatter#ISO_LOCAL_DATE}.
-     * @param text the text to parse such as "2007-12-03", not null
-     * @return the parsed local date, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence): LocalDate;
-
-    /**
-     * Obtains an instance of {@code LocalDate} from a text string using a specific formatter.
-     *  <p>
-     *  The text is parsed using the formatter, returning a date.
-     * @param text the text to parse, not null
-     * @param formatter the formatter to use, not null
-     * @return the parsed local date, not null
-     * @throws DateTimeParseException if the text cannot be parsed
-     */
-    parse(text: CharSequence, formatter: DateTimeFormatter): LocalDate;
-
     /**
      * Checks if the specified field is supported.
      *  <p>

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

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