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

package/types/java/text/NumberFormat/index.d.ts

@@ -6,8 +6,6 @@ import type { ParsePosition } from "../ParsePosition";
 
 import type { Number } from "../../lang/Number";
 
-import type { Locale } from "../../util/Locale";
-
 import type { Currency } from "../../util/Currency";
 import type { RoundingMode } from "../../math/RoundingMode";
 import type { Format } from "../Format";
@@ -282,127 +280,6 @@ export type NumberFormat = Format & {
    */
   setParseIntegerOnly(value: boolean): void;
 
-  /**
-   * Returns a general-purpose number format for the current default
-   *  {@link java.util.Locale.Category#FORMAT FORMAT} locale.
-   *  This is the same as calling
-   *  {@link #getNumberInstance() getNumberInstance()}.
-   * @return the {@code NumberFormat} instance for general-purpose number
 formatting
-   */
-  getInstance(): NumberFormat;
-
-  /**
-   * Returns a general-purpose number format for the specified locale.
-   *  This is the same as calling
-   *  {@link #getNumberInstance(java.util.Locale) getNumberInstance(inLocale)}.
-   * @param inLocale the desired locale
-   * @return the {@code NumberFormat} instance for general-purpose number
 formatting
-   */
-  getInstance(inLocale: Locale): NumberFormat;
-
-  /**
-   * Returns a general-purpose number format for the current default
-   *  {@link java.util.Locale.Category#FORMAT FORMAT} locale.
-   *  <p>This is equivalent to calling
-   *  {@link #getNumberInstance(Locale)
-   *      getNumberInstance(Locale.getDefault(Locale.Category.FORMAT))}.
-   * @return the {@code NumberFormat} instance for general-purpose number&#xA; formatting
-   * @see java.util.Locale#getDefault(java.util.Locale.Category)
-   * @see java.util.Locale.Category#FORMAT
-   */
-  getNumberInstance(): NumberFormat;
-
-  /**
-   * Returns a general-purpose number format for the specified locale.
-   * @param inLocale the desired locale
-   * @return the {@code NumberFormat} instance for general-purpose number&#xA; formatting
-   */
-  getNumberInstance(inLocale: Locale): NumberFormat;
-
-  /**
-   * Returns an integer number format for the current default
-   *  {@link java.util.Locale.Category#FORMAT FORMAT} locale. The
-   *  returned number format is configured to round floating point numbers
-   *  to the nearest integer using half-even rounding (see {@link
-   *  java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}) for formatting,
-   *  and to parse only the integer part of an input string (see {@link
-   *  #isParseIntegerOnly isParseIntegerOnly}).
-   *  <p>This is equivalent to calling
-   *  {@link #getIntegerInstance(Locale)
-   *      getIntegerInstance(Locale.getDefault(Locale.Category.FORMAT))}.
-   * @see #getRoundingMode()
-   * @see java.util.Locale#getDefault(java.util.Locale.Category)
-   * @see java.util.Locale.Category#FORMAT
-   * @return a number format for integer values
-   * @since 1.4
-   */
-  getIntegerInstance(): NumberFormat;
-
-  /**
-   * Returns an integer number format for the specified locale. The
-   *  returned number format is configured to round floating point numbers
-   *  to the nearest integer using half-even rounding (see {@link
-   *  java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}) for formatting,
-   *  and to parse only the integer part of an input string (see {@link
-   *  #isParseIntegerOnly isParseIntegerOnly}).
-   * @param inLocale the desired locale
-   * @see #getRoundingMode()
-   * @return a number format for integer values
-   * @since 1.4
-   */
-  getIntegerInstance(inLocale: Locale): NumberFormat;
-
-  /**
-   * Returns a currency format for the current default
-   *  {@link java.util.Locale.Category#FORMAT FORMAT} locale.
-   *  <p>This is equivalent to calling
-   *  {@link #getCurrencyInstance(Locale)
-   *      getCurrencyInstance(Locale.getDefault(Locale.Category.FORMAT))}.
-   * @return the {@code NumberFormat} instance for currency formatting
-   * @see java.util.Locale#getDefault(java.util.Locale.Category)
-   * @see java.util.Locale.Category#FORMAT
-   */
-  getCurrencyInstance(): NumberFormat;
-
-  /**
-   * Returns a currency format for the specified locale.
-   * @param inLocale the desired locale
-   * @return the {@code NumberFormat} instance for currency formatting
-   */
-  getCurrencyInstance(inLocale: Locale): NumberFormat;
-
-  /**
-   * Returns a percentage format for the current default
-   *  {@link java.util.Locale.Category#FORMAT FORMAT} locale.
-   *  <p>This is equivalent to calling
-   *  {@link #getPercentInstance(Locale)
-   *      getPercentInstance(Locale.getDefault(Locale.Category.FORMAT))}.
-   * @return the {@code NumberFormat} instance for percentage formatting
-   * @see java.util.Locale#getDefault(java.util.Locale.Category)
-   * @see java.util.Locale.Category#FORMAT
-   */
-  getPercentInstance(): NumberFormat;
-
-  /**
-   * Returns a percentage format for the specified locale.
-   * @param inLocale the desired locale
-   * @return the {@code NumberFormat} instance for percentage formatting
-   */
-  getPercentInstance(inLocale: Locale): NumberFormat;
-
-  /**
-   * Returns an array of all locales for which the
-   *  <code>get*Instance</code> methods of this class can return
-   *  localized instances.
-   *  The returned array represents the union of locales supported by the Java
-   *  runtime and by installed
-   *  {@link java.text.spi.NumberFormatProvider NumberFormatProvider} implementations.
-   *  It must contain at least a <code>Locale</code> instance equal to
-   *  {@link java.util.Locale#US Locale.US}.
-   * @return An array of locales for which localized&#xA; <code>NumberFormat</code> instances are available.
-   */
-  getAvailableLocales(): Locale;
-
   /**
  * Overrides hashCode.
   

package/types/java/text/NumberFormat/index.js

@@ -10,12 +10,6 @@ var _default = {
   parse: function parse() {},
   isParseIntegerOnly: function isParseIntegerOnly() {},
   setParseIntegerOnly: function setParseIntegerOnly() {},
-  getInstance: function getInstance() {},
-  getNumberInstance: function getNumberInstance() {},
-  getIntegerInstance: function getIntegerInstance() {},
-  getCurrencyInstance: function getCurrencyInstance() {},
-  getPercentInstance: function getPercentInstance() {},
-  getAvailableLocales: function getAvailableLocales() {},
   hashCode: function hashCode() {},
   equals: function equals() {},
   clone: function clone() {},

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

@@ -1,7 +1,6 @@
 import type { ZoneId } from "../ZoneId";
-import type { Duration } from "../Duration";
-import type { Instant } from "../Instant";
 
+import type { Instant } from "../Instant";
 import type { Object } from "../../lang/Object";
 
 /**
@@ -43,166 +42,6 @@ import type { Object } from "../../lang/Object";
  * @since 1.8
  */
 export type Clock = Object & {
-  /**
-   * Obtains a clock that returns the current instant using the best available
-   *  system clock, converting to date and time using the UTC time-zone.
-   *  <p>
-   *  This clock, rather than {@link #systemDefaultZone()}, should be used when
-   *  you need the current instant without the date or time.
-   *  <p>
-   *  This clock is based on the best available system clock.
-   *  This may use {@link System#currentTimeMillis()}, or a higher resolution
-   *  clock if one is available.
-   *  <p>
-   *  Conversion from instant to date or time uses the {@linkplain ZoneOffset#UTC UTC time-zone}.
-   *  <p>
-   *  The returned implementation is immutable, thread-safe and {@code Serializable}.
-   *  It is equivalent to {@code system(ZoneOffset.UTC)}.
-   * @return a clock that uses the best available system clock in the UTC zone, not null
-   */
-  systemUTC(): Clock;
-
-  /**
-   * Obtains a clock that returns the current instant using the best available
-   *  system clock, converting to date and time using the default time-zone.
-   *  <p>
-   *  This clock is based on the best available system clock.
-   *  This may use {@link System#currentTimeMillis()}, or a higher resolution
-   *  clock if one is available.
-   *  <p>
-   *  Using this method hard codes a dependency to the default time-zone into your application.
-   *  It is recommended to avoid this and use a specific time-zone whenever possible.
-   *  The {@link #systemUTC() UTC clock} should be used when you need the current instant
-   *  without the date or time.
-   *  <p>
-   *  The returned implementation is immutable, thread-safe and {@code Serializable}.
-   *  It is equivalent to {@code system(ZoneId.systemDefault())}.
-   * @return a clock that uses the best available system clock in the default zone, not null
-   * @see ZoneId#systemDefault()
-   */
-  systemDefaultZone(): Clock;
-
-  /**
-   * Obtains a clock that returns the current instant using best available
-   *  system clock.
-   *  <p>
-   *  This clock is based on the best available system clock.
-   *  This may use {@link System#currentTimeMillis()}, or a higher resolution
-   *  clock if one is available.
-   *  <p>
-   *  Conversion from instant to date or time uses the specified time-zone.
-   *  <p>
-   *  The returned implementation is immutable, thread-safe and {@code Serializable}.
-   * @param zone the time-zone to use to convert the instant to date-time, not null
-   * @return a clock that uses the best available system clock in the specified zone, not null
-   */
-  system(zone: ZoneId): Clock;
-
-  /**
-   * Obtains a clock that returns the current instant ticking in whole seconds
-   *  using best available system clock.
-   *  <p>
-   *  This clock will always have the nano-of-second field set to zero.
-   *  This ensures that the visible time ticks in whole seconds.
-   *  The underlying clock is the best available system clock, equivalent to
-   *  using {@link #system(ZoneId)}.
-   *  <p>
-   *  Implementations may use a caching strategy for performance reasons.
-   *  As such, it is possible that the start of the second observed via this
-   *  clock will be later than that observed directly via the underlying clock.
-   *  <p>
-   *  The returned implementation is immutable, thread-safe and {@code Serializable}.
-   *  It is equivalent to {@code tick(system(zone), Duration.ofSeconds(1))}.
-   * @param zone the time-zone to use to convert the instant to date-time, not null
-   * @return a clock that ticks in whole seconds using the specified zone, not null
-   */
-  tickSeconds(zone: ZoneId): Clock;
-
-  /**
-   * Obtains a clock that returns the current instant ticking in whole minutes
-   *  using best available system clock.
-   *  <p>
-   *  This clock will always have the nano-of-second and second-of-minute fields set to zero.
-   *  This ensures that the visible time ticks in whole minutes.
-   *  The underlying clock is the best available system clock, equivalent to
-   *  using {@link #system(ZoneId)}.
-   *  <p>
-   *  Implementations may use a caching strategy for performance reasons.
-   *  As such, it is possible that the start of the minute observed via this
-   *  clock will be later than that observed directly via the underlying clock.
-   *  <p>
-   *  The returned implementation is immutable, thread-safe and {@code Serializable}.
-   *  It is equivalent to {@code tick(system(zone), Duration.ofMinutes(1))}.
-   * @param zone the time-zone to use to convert the instant to date-time, not null
-   * @return a clock that ticks in whole minutes using the specified zone, not null
-   */
-  tickMinutes(zone: ZoneId): Clock;
-
-  /**
-   * Obtains a clock that returns instants from the specified clock truncated
-   *  to the nearest occurrence of the specified duration.
-   *  <p>
-   *  This clock will only tick as per the specified duration. Thus, if the duration
-   *  is half a second, the clock will return instants truncated to the half second.
-   *  <p>
-   *  The tick duration must be positive. If it has a part smaller than a whole
-   *  millisecond, then the whole duration must divide into one second without
-   *  leaving a remainder. All normal tick durations will match these criteria,
-   *  including any multiple of hours, minutes, seconds and milliseconds, and
-   *  sensible nanosecond durations, such as 20ns, 250,000ns and 500,000ns.
-   *  <p>
-   *  A duration of zero or one nanosecond would have no truncation effect.
-   *  Passing one of these will return the underlying clock.
-   *  <p>
-   *  Implementations may use a caching strategy for performance reasons.
-   *  As such, it is possible that the start of the requested duration observed
-   *  via this clock will be later than that observed directly via the underlying clock.
-   *  <p>
-   *  The returned implementation is immutable, thread-safe and {@code Serializable}
-   *  providing that the base clock is.
-   * @param baseClock the base clock to base the ticking clock on, not null
-   * @param tickDuration the duration of each visible tick, not negative, not null
-   * @return a clock that ticks in whole units of the duration, not null
-   * @throws IllegalArgumentException if the duration is negative, or has a&#xA; part smaller than a whole millisecond such that the whole duration is not&#xA; divisible into one second
-   * @throws ArithmeticException if the duration is too large to be represented as nanos
-   */
-  tick(baseClock: Clock, tickDuration: Duration): Clock;
-
-  /**
-   * Obtains a clock that always returns the same instant.
-   *  <p>
-   *  This clock simply returns the specified instant.
-   *  As such, it is not a clock in the conventional sense.
-   *  The main use case for this is in testing, where the fixed clock ensures
-   *  tests are not dependent on the current clock.
-   *  <p>
-   *  The returned implementation is immutable, thread-safe and {@code Serializable}.
-   * @param fixedInstant the instant to use as the clock, not null
-   * @param zone the time-zone to use to convert the instant to date-time, not null
-   * @return a clock that always returns the same instant, not null
-   */
-  fixed(fixedInstant: Instant, zone: ZoneId): Clock;
-
-  /**
-   * Obtains a clock that returns instants from the specified clock with the
-   *  specified duration added
-   *  <p>
-   *  This clock wraps another clock, returning instants that are later by the
-   *  specified duration. If the duration is negative, the instants will be
-   *  earlier than the current date and time.
-   *  The main use case for this is to simulate running in the future or in the past.
-   *  <p>
-   *  A duration of zero would have no offsetting effect.
-   *  Passing zero will return the underlying clock.
-   *  <p>
-   *  The returned implementation is immutable, thread-safe and {@code Serializable}
-   *  providing that the base clock is.
-   * @param baseClock the base clock to add the duration to, not null
-   * @param offsetDuration the duration to add, not null
-   * @return a clock based on the base clock with the duration added, not null
-   */
-  offset(baseClock: Clock, offsetDuration: Duration): Clock;
-
   /**
    * Gets the time-zone being used to create dates and times.
    *  <p>

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>