@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/util/NavigableSet/index.d.ts

@@ -0,0 +1,228 @@
+import type { Iterator } from "../Iterator";
+
+import type { SortedSet } from "../SortedSet";
+
+/**
+ * A {@link SortedSet} extended with navigation methods reporting
+ *  closest matches for given search targets. Methods {@code lower},
+ *  {@code floor}, {@code ceiling}, and {@code higher} return elements
+ *  respectively less than, less than or equal, greater than or equal,
+ *  and greater than a given element, returning {@code null} if there
+ *  is no such element.  A {@code NavigableSet} may be accessed and
+ *  traversed in either ascending or descending order.  The {@code
+ *  descendingSet} method returns a view of the set with the senses of
+ *  all relational and directional methods inverted. The performance of
+ *  ascending operations and views is likely to be faster than that of
+ *  descending ones.  This interface additionally defines methods
+ *  {@code pollFirst} and {@code pollLast} that return and remove the
+ *  lowest and highest element, if one exists, else returning {@code
+ *  null}.  Methods {@code subSet}, {@code headSet},
+ *  and {@code tailSet} differ from the like-named {@code
+ *  SortedSet} methods in accepting additional arguments describing
+ *  whether lower and upper bounds are inclusive versus exclusive.
+ *  Subsets of any {@code NavigableSet} must implement the {@code
+ *  NavigableSet} interface.
+ *
+ *  <p> The return values of navigation methods may be ambiguous in
+ *  implementations that permit {@code null} elements. However, even
+ *  in this case the result can be disambiguated by checking
+ *  {@code contains(null)}. To avoid such issues, implementations of
+ *  this interface are encouraged to <em>not</em> permit insertion of
+ *  {@code null} elements. (Note that sorted sets of {@link
+ *  Comparable} elements intrinsically do not permit {@code null}.)
+ *
+ *  <p>Methods
+ *  {@link #subSet(Object, Object) subSet(E, E)},
+ *  {@link #headSet(Object) headSet(E)}, and
+ *  {@link #tailSet(Object) tailSet(E)}
+ *  are specified to return {@code SortedSet} to allow existing
+ *  implementations of {@code SortedSet} to be compatibly retrofitted to
+ *  implement {@code NavigableSet}, but extensions and implementations
+ *  of this interface are encouraged to override these methods to return
+ *  {@code NavigableSet}.
+ *
+ *  <p>This interface is a member of the
+ *  <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ *  Java Collections Framework</a>.
+ * @author Doug Lea
+ * @author Josh Bloch
+ * @param <E> the type of elements maintained by this set
+ * @since 1.6
+ */
+export type NavigableSet = SortedSet & {
+  /**
+   * Returns the greatest element in this set strictly less than the
+   *  given element, or {@code null} if there is no such element.
+   * @param e the value to match
+   * @return the greatest element less than {@code e},&#xA; or {@code null} if there is no such element
+   * @throws ClassCastException if the specified element cannot be&#xA; compared with the elements currently in the set
+   * @throws NullPointerException if the specified element is null&#xA; and this set does not permit null elements
+   */
+  lower(e: unknown): unknown;
+
+  /**
+   * Returns the greatest element in this set less than or equal to
+   *  the given element, or {@code null} if there is no such element.
+   * @param e the value to match
+   * @return the greatest element less than or equal to {@code e},&#xA; or {@code null} if there is no such element
+   * @throws ClassCastException if the specified element cannot be&#xA; compared with the elements currently in the set
+   * @throws NullPointerException if the specified element is null&#xA; and this set does not permit null elements
+   */
+  floor(e: unknown): unknown;
+
+  /**
+   * Returns the least element in this set greater than or equal to
+   *  the given element, or {@code null} if there is no such element.
+   * @param e the value to match
+   * @return the least element greater than or equal to {@code e},&#xA; or {@code null} if there is no such element
+   * @throws ClassCastException if the specified element cannot be&#xA; compared with the elements currently in the set
+   * @throws NullPointerException if the specified element is null&#xA; and this set does not permit null elements
+   */
+  ceiling(e: unknown): unknown;
+
+  /**
+   * Returns the least element in this set strictly greater than the
+   *  given element, or {@code null} if there is no such element.
+   * @param e the value to match
+   * @return the least element greater than {@code e},&#xA; or {@code null} if there is no such element
+   * @throws ClassCastException if the specified element cannot be&#xA; compared with the elements currently in the set
+   * @throws NullPointerException if the specified element is null&#xA; and this set does not permit null elements
+   */
+  higher(e: unknown): unknown;
+
+  /**
+   * Retrieves and removes the first (lowest) element,
+   *  or returns {@code null} if this set is empty.
+   * @return the first element, or {@code null} if this set is empty
+   */
+  pollFirst(): unknown;
+
+  /**
+   * Retrieves and removes the last (highest) element,
+   *  or returns {@code null} if this set is empty.
+   * @return the last element, or {@code null} if this set is empty
+   */
+  pollLast(): unknown;
+
+  /**
+   * Returns an iterator over the elements in this set, in ascending order.
+   * @return an iterator over the elements in this set, in ascending order
+   */
+  iterator(): Iterator;
+
+  /**
+   * Returns a reverse order view of the elements contained in this set.
+   *  The descending set is backed by this set, so changes to the set are
+   *  reflected in the descending set, and vice-versa.  If either set is
+   *  modified while an iteration over either set is in progress (except
+   *  through the iterator's own {@code remove} operation), the results of
+   *  the iteration are undefined.
+   *
+   *  <p>The returned set has an ordering equivalent to
+   *  <tt>{@link Collections#reverseOrder(Comparator) Collections.reverseOrder}(comparator())</tt>.
+   *  The expression {@code s.descendingSet().descendingSet()} returns a
+   *  view of {@code s} essentially equivalent to {@code s}.
+   * @return a reverse order view of this set
+   */
+  descendingSet(): NavigableSet;
+
+  /**
+   * Returns an iterator over the elements in this set, in descending order.
+   *  Equivalent in effect to {@code descendingSet().iterator()}.
+   * @return an iterator over the elements in this set, in descending order
+   */
+  descendingIterator(): Iterator;
+
+  /**
+   * Returns a view of the portion of this set whose elements range from
+   *  {@code fromElement} to {@code toElement}.  If {@code fromElement} and
+   *  {@code toElement} are equal, the returned set is empty unless {@code
+   *  fromInclusive} and {@code toInclusive} are both true.  The returned set
+   *  is backed by this set, so changes in the returned set are reflected in
+   *  this set, and vice-versa.  The returned set supports all optional set
+   *  operations that this set supports.
+   *
+   *  <p>The returned set will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert an element outside its range.
+   * @param fromElement low endpoint of the returned set
+   * @param fromInclusive {@code true} if the low endpoint&#xA; is to be included in the returned view
+   * @param toElement high endpoint of the returned set
+   * @param toInclusive {@code true} if the high endpoint&#xA; is to be included in the returned view
+   * @return a view of the portion of this set whose elements range from&#xA; {@code fromElement}, inclusive, to {@code toElement}, exclusive
+   * @throws ClassCastException if {@code fromElement} and&#xA; {@code toElement} cannot be compared to one another using this&#xA; set's comparator (or, if the set has no comparator, using&#xA; natural ordering). Implementations may, but are not required&#xA; to, throw this exception if {@code fromElement} or&#xA; {@code toElement} cannot be compared to elements currently in&#xA; the set.
+   * @throws NullPointerException if {@code fromElement} or&#xA; {@code toElement} is null and this set does&#xA; not permit null elements
+   * @throws IllegalArgumentException if {@code fromElement} is&#xA; greater than {@code toElement}; or if this set itself&#xA; has a restricted range, and {@code fromElement} or&#xA; {@code toElement} lies outside the bounds of the range.
+   */
+  subSet(
+    fromElement: unknown,
+    fromInclusive: boolean,
+    toElement: unknown,
+    toInclusive: boolean
+  ): NavigableSet;
+
+  /**
+   * Returns a view of the portion of this set whose elements are less than
+   *  (or equal to, if {@code inclusive} is true) {@code toElement}.  The
+   *  returned set is backed by this set, so changes in the returned set are
+   *  reflected in this set, and vice-versa.  The returned set supports all
+   *  optional set operations that this set supports.
+   *
+   *  <p>The returned set will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert an element outside its range.
+   * @param toElement high endpoint of the returned set
+   * @param inclusive {@code true} if the high endpoint&#xA; is to be included in the returned view
+   * @return a view of the portion of this set whose elements are less than&#xA; (or equal to, if {@code inclusive} is true) {@code toElement}
+   * @throws ClassCastException if {@code toElement} is not compatible&#xA; with this set's comparator (or, if the set has no comparator,&#xA; if {@code toElement} does not implement {@link Comparable}).&#xA; Implementations may, but are not required to, throw this&#xA; exception if {@code toElement} cannot be compared to elements&#xA; currently in the set.
+   * @throws NullPointerException if {@code toElement} is null and&#xA; this set does not permit null elements
+   * @throws IllegalArgumentException if this set itself has a&#xA; restricted range, and {@code toElement} lies outside the&#xA; bounds of the range
+   */
+  headSet(toElement: unknown, inclusive: boolean): NavigableSet;
+
+  /**
+   * Returns a view of the portion of this set whose elements are greater
+   *  than (or equal to, if {@code inclusive} is true) {@code fromElement}.
+   *  The returned set is backed by this set, so changes in the returned set
+   *  are reflected in this set, and vice-versa.  The returned set supports
+   *  all optional set operations that this set supports.
+   *
+   *  <p>The returned set will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert an element outside its range.
+   * @param fromElement low endpoint of the returned set
+   * @param inclusive {@code true} if the low endpoint&#xA; is to be included in the returned view
+   * @return a view of the portion of this set whose elements are greater&#xA; than or equal to {@code fromElement}
+   * @throws ClassCastException if {@code fromElement} is not compatible&#xA; with this set's comparator (or, if the set has no comparator,&#xA; if {@code fromElement} does not implement {@link Comparable}).&#xA; Implementations may, but are not required to, throw this&#xA; exception if {@code fromElement} cannot be compared to elements&#xA; currently in the set.
+   * @throws NullPointerException if {@code fromElement} is null&#xA; and this set does not permit null elements
+   * @throws IllegalArgumentException if this set itself has a&#xA; restricted range, and {@code fromElement} lies outside the&#xA; bounds of the range
+   */
+  tailSet(fromElement: unknown, inclusive: boolean): NavigableSet;
+
+  /**
+   * {@inheritDoc}
+   *
+   *  <p>Equivalent to {@code subSet(fromElement, true, toElement, false)}.
+   * @throws ClassCastException {@inheritDoc}
+   * @throws NullPointerException {@inheritDoc}
+   * @throws IllegalArgumentException {@inheritDoc}
+   */
+  subSet(fromElement: unknown, toElement: unknown): SortedSet;
+
+  /**
+   * {@inheritDoc}
+   *
+   *  <p>Equivalent to {@code headSet(toElement, false)}.
+   * @throws ClassCastException {@inheritDoc}
+   * @throws NullPointerException {@inheritDoc}
+   * @throws IllegalArgumentException {@inheritDoc}
+   */
+  headSet(toElement: unknown): SortedSet;
+
+  /**
+   * {@inheritDoc}
+   *
+   *  <p>Equivalent to {@code tailSet(fromElement, true)}.
+   * @throws ClassCastException {@inheritDoc}
+   * @throws NullPointerException {@inheritDoc}
+   * @throws IllegalArgumentException {@inheritDoc}
+   */
+  tailSet(fromElement: unknown): SortedSet;
+};

package/types/java/util/NavigableSet/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  lower: function lower() {},
+  floor: function floor() {},
+  ceiling: function ceiling() {},
+  higher: function higher() {},
+  pollFirst: function pollFirst() {},
+  pollLast: function pollLast() {},
+  iterator: function iterator() {},
+  descendingSet: function descendingSet() {},
+  descendingIterator: function descendingIterator() {},
+  subSet: function subSet() {},
+  headSet: function headSet() {},
+  tailSet: function tailSet() {}
+};
+exports["default"] = _default;

package/types/java/util/Optional/index.d.ts

@@ -0,0 +1,170 @@
+import type { Consumer } from "../function/Consumer";
+
+import type { Predicate } from "../function/Predicate";
+import type { Function } from "../function/Function";
+import type { Supplier } from "../function/Supplier";
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+
+/**
+ * A container object which may or may not contain a non-null value.
+ *  If a value is present, {@code isPresent()} will return {@code true} and
+ *  {@code get()} will return the value.
+ *
+ *  <p>Additional methods that depend on the presence or absence of a contained
+ *  value are provided, such as {@link #orElse(java.lang.Object) orElse()}
+ *  (return a default value if value not present) and
+ *  {@link #ifPresent(java.util.function.Consumer) ifPresent()} (execute a block
+ *  of code if the value is present).
+ *
+ *  <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
+ *  class; use of identity-sensitive operations (including reference equality
+ *  ({@code ==}), identity hash code, or synchronization) on instances of
+ *  {@code Optional} may have unpredictable results and should be avoided.
+ * @since 1.8
+ */
+export type Optional = Object & {
+  /**
+   * Returns an empty {@code Optional} instance.  No value is present for this
+   *  Optional.
+   * @apiNote Though it may be tempting to do so, avoid testing if an object&#xA; is empty by comparing with {@code ==} against instances returned by&#xA; {@code Option.empty()}. There is no guarantee that it is a singleton.&#xA; Instead, use {@link #isPresent()}.
+   * @param <T> Type of the non-existent value
+   * @return an empty {@code Optional}
+   */
+  empty(): Optional;
+
+  /**
+   * Returns an {@code Optional} with the specified present non-null value.
+   * @param <T> the class of the value
+   * @param value the value to be present, which must be non-null
+   * @return an {@code Optional} with the value present
+   * @throws NullPointerException if value is null
+   */
+  of(value: unknown): Optional;
+
+  /**
+   * Returns an {@code Optional} describing the specified value, if non-null,
+   *  otherwise returns an empty {@code Optional}.
+   * @param <T> the class of the value
+   * @param value the possibly-null value to describe
+   * @return an {@code Optional} with a present value if the specified value&#xA; is non-null, otherwise an empty {@code Optional}
+   */
+  ofNullable(value: unknown): Optional;
+
+  /**
+   * If a value is present in this {@code Optional}, returns the value,
+   *  otherwise throws {@code NoSuchElementException}.
+   * @return the non-null value held by this {@code Optional}
+   * @throws NoSuchElementException if there is no value present
+   * @see Optional#isPresent()
+   */
+  get(): unknown;
+
+  /**
+   * Return {@code true} if there is a value present, otherwise {@code false}.
+   * @return {@code true} if there is a value present, otherwise {@code false}
+   */
+  isPresent(): boolean;
+
+  /**
+   * If a value is present, invoke the specified consumer with the value,
+   *  otherwise do nothing.
+   * @param consumer block to be executed if a value is present
+   * @throws NullPointerException if value is present and {@code consumer} is&#xA; null
+   */
+  ifPresent(consumer: Consumer): void;
+
+  /**
+   * If a value is present, and the value matches the given predicate,
+   *  return an {@code Optional} describing the value, otherwise return an
+   *  empty {@code Optional}.
+   * @param predicate a predicate to apply to the value, if present
+   * @return an {@code Optional} describing the value of this {@code Optional}&#xA; if a value is present and the value matches the given predicate,&#xA; otherwise an empty {@code Optional}
+   * @throws NullPointerException if the predicate is null
+   */
+  filter(predicate: Predicate): Optional;
+
+  /**
+   * If a value is present, apply the provided mapping function to it,
+   *  and if the result is non-null, return an {@code Optional} describing the
+   *  result.  Otherwise return an empty {@code Optional}.
+   * @apiNote This method supports post-processing on optional values, without&#xA; the need to explicitly check for a return status. For example, the&#xA; following code traverses a stream of file names, selects one that has&#xA; not yet been processed, and then opens that file, returning an&#xA; {@code Optional<FileInputStream>}:&#xA;&#xA; <pre>{@code&#xA; Optional<FileInputStream> fis =&#xA; names.stream().filter(name -> !isProcessedYet(name))&#xA; .findFirst()&#xA; .map(name -> new FileInputStream(name));&#xA; }</pre>&#xA;&#xA; Here, {@code findFirst} returns an {@code Optional<String>}, and then&#xA; {@code map} returns an {@code Optional<FileInputStream>} for the desired&#xA; file if one exists.
+   * @param <U> The type of the result of the mapping function
+   * @param mapper a mapping function to apply to the value, if present
+   * @return an {@code Optional} describing the result of applying a mapping&#xA; function to the value of this {@code Optional}, if a value is present,&#xA; otherwise an empty {@code Optional}
+   * @throws NullPointerException if the mapping function is null
+   */
+  map(mapper: Function): Optional;
+
+  /**
+   * If a value is present, apply the provided {@code Optional}-bearing
+   *  mapping function to it, return that result, otherwise return an empty
+   *  {@code Optional}.  This method is similar to {@link #map(Function)},
+   *  but the provided mapper is one whose result is already an {@code Optional},
+   *  and if invoked, {@code flatMap} does not wrap it with an additional
+   *  {@code Optional}.
+   * @param <U> The type parameter to the {@code Optional} returned by
+   * @param mapper a mapping function to apply to the value, if present&#xA; the mapping function
+   * @return the result of applying an {@code Optional}-bearing mapping&#xA; function to the value of this {@code Optional}, if a value is present,&#xA; otherwise an empty {@code Optional}
+   * @throws NullPointerException if the mapping function is null or returns&#xA; a null result
+   */
+  flatMap(mapper: Function): Optional;
+
+  /**
+   * Return the value if present, otherwise return {@code other}.
+   * @param other the value to be returned if there is no value present, may&#xA; be null
+   * @return the value, if present, otherwise {@code other}
+   */
+  orElse(other: unknown): unknown;
+
+  /**
+   * Return the value if present, otherwise invoke {@code other} and return
+   *  the result of that invocation.
+   * @param other a {@code Supplier} whose result is returned if no value&#xA; is present
+   * @return the value if present otherwise the result of {@code other.get()}
+   * @throws NullPointerException if value is not present and {@code other} is&#xA; null
+   */
+  orElseGet(other: Supplier): unknown;
+
+  /**
+   * Return the contained value, if present, otherwise throw an exception
+   *  to be created by the provided supplier.
+   * @apiNote A method reference to the exception constructor with an empty&#xA; argument list can be used as the supplier. For example,&#xA; {@code IllegalStateException::new}
+   * @param <X> Type of the exception to be thrown
+   * @param exceptionSupplier The supplier which will return the exception to&#xA; be thrown
+   * @return the present value
+   * @throws X if there is no value present
+   * @throws NullPointerException if no value is present and&#xA; {@code exceptionSupplier} is null
+   */
+  orElseThrow(exceptionSupplier: Supplier): unknown;
+
+  /**
+   * Indicates whether some other object is "equal to" this Optional. The
+   *  other object is considered equal if:
+   *  <ul>
+   *  <li>it is also an {@code Optional} and;
+   *  <li>both instances have no value present or;
+   *  <li>the present values are "equal to" each other via {@code equals()}.
+   *  </ul>
+   * @param obj an object to be tested for equality
+   * @return {code true} if the other object is "equal to" this object&#xA; otherwise {@code false}
+   */
+  equals(obj: unknown): boolean;
+
+  /**
+   * Returns the hash code value of the present value, if any, or 0 (zero) if
+   *  no value is present.
+   * @return hash code value of the present value or 0 if no value is present
+   */
+  hashCode(): number;
+
+  /**
+   * Returns a non-empty string representation of this Optional suitable for
+   *  debugging. The exact presentation format is unspecified and may vary
+   *  between implementations and versions.
+   * @implSpec If a value is present the result must include its string&#xA; representation in the result. Empty and present Optionals must be&#xA; unambiguously differentiable.
+   * @return the string representation of this instance
+   */
+  toString(): string;
+};

package/types/java/util/Optional/index.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  empty: function empty() {},
+  of: function of() {},
+  ofNullable: function ofNullable() {},
+  get: function get() {},
+  isPresent: function isPresent() {},
+  ifPresent: function ifPresent() {},
+  filter: function filter() {},
+  map: function map() {},
+  flatMap: function flatMap() {},
+  orElse: function orElse() {},
+  orElseGet: function orElseGet() {},
+  orElseThrow: function orElseThrow() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

package/types/java/util/OptionalDouble/index.d.ts

@@ -0,0 +1,123 @@
+import type { DoubleConsumer } from "../function/DoubleConsumer";
+
+import type { DoubleSupplier } from "../function/DoubleSupplier";
+import type { Supplier } from "../function/Supplier";
+import type { Object } from "../../lang/Object";
+
+import type { String } from "../../lang/String";
+
+/**
+ * A container object which may or may not contain a {@code double} value.
+ *  If a value is present, {@code isPresent()} will return {@code true} and
+ *  {@code getAsDouble()} will return the value.
+ *
+ *  <p>Additional methods that depend on the presence or absence of a contained
+ *  value are provided, such as {@link #orElse(double) orElse()}
+ *  (return a default value if value not present) and
+ *  {@link #ifPresent(java.util.function.DoubleConsumer) ifPresent()} (execute a block
+ *  of code if the value is present).
+ *
+ *  <p>This is a <a href="../lang/doc-files/ValueBased.html">value-based</a>
+ *  class; use of identity-sensitive operations (including reference equality
+ *  ({@code ==}), identity hash code, or synchronization) on instances of
+ *  {@code OptionalDouble} may have unpredictable results and should be avoided.
+ * @since 1.8
+ */
+export type OptionalDouble = Object & {
+  /**
+   * Returns an empty {@code OptionalDouble} instance.  No value is present for this
+   *  OptionalDouble.
+   * @apiNote Though it may be tempting to do so, avoid testing if an object&#xA; is empty by comparing with {@code ==} against instances returned by&#xA; {@code Option.empty()}. There is no guarantee that it is a singleton.&#xA; Instead, use {@link #isPresent()}.
+   * @return an empty {@code OptionalDouble}.
+   */
+  empty(): OptionalDouble;
+
+  /**
+   * Return an {@code OptionalDouble} with the specified value present.
+   * @param value the value to be present
+   * @return an {@code OptionalDouble} with the value present
+   */
+  of(value: number): OptionalDouble;
+
+  /**
+   * If a value is present in this {@code OptionalDouble}, returns the value,
+   *  otherwise throws {@code NoSuchElementException}.
+   * @return the value held by this {@code OptionalDouble}
+   * @throws NoSuchElementException if there is no value present
+   * @see OptionalDouble#isPresent()
+   */
+  getAsDouble(): number;
+
+  /**
+   * Return {@code true} if there is a value present, otherwise {@code false}.
+   * @return {@code true} if there is a value present, otherwise {@code false}
+   */
+  isPresent(): boolean;
+
+  /**
+   * Have the specified consumer accept the value if a value is present,
+   *  otherwise do nothing.
+   * @param consumer block to be executed if a value is present
+   * @throws NullPointerException if value is present and {@code consumer} is&#xA; null
+   */
+  ifPresent(consumer: DoubleConsumer): void;
+
+  /**
+   * Return the value if present, otherwise return {@code other}.
+   * @param other the value to be returned if there is no value present
+   * @return the value, if present, otherwise {@code other}
+   */
+  orElse(other: number): number;
+
+  /**
+   * Return the value if present, otherwise invoke {@code other} and return
+   *  the result of that invocation.
+   * @param other a {@code DoubleSupplier} whose result is returned if no value&#xA; is present
+   * @return the value if present otherwise the result of {@code other.getAsDouble()}
+   * @throws NullPointerException if value is not present and {@code other} is&#xA; null
+   */
+  orElseGet(other: DoubleSupplier): number;
+
+  /**
+   * Return the contained value, if present, otherwise throw an exception
+   *  to be created by the provided supplier.
+   * @apiNote A method reference to the exception constructor with an empty&#xA; argument list can be used as the supplier. For example,&#xA; {@code IllegalStateException::new}
+   * @param <X> Type of the exception to be thrown
+   * @param exceptionSupplier The supplier which will return the exception to&#xA; be thrown
+   * @return the present value
+   * @throws X if there is no value present
+   * @throws NullPointerException if no value is present and&#xA; {@code exceptionSupplier} is null
+   */
+  orElseThrow(exceptionSupplier: Supplier): number;
+
+  /**
+   * Indicates whether some other object is "equal to" this OptionalDouble. The
+   *  other object is considered equal if:
+   *  <ul>
+   *  <li>it is also an {@code OptionalDouble} and;
+   *  <li>both instances have no value present or;
+   *  <li>the present values are "equal to" each other via {@code Double.compare() == 0}.
+   *  </ul>
+   * @param obj an object to be tested for equality
+   * @return {code true} if the other object is "equal to" this object&#xA; otherwise {@code false}
+   */
+  equals(obj: unknown): boolean;
+
+  /**
+   * Returns the hash code value of the present value, if any, or 0 (zero) if
+   *  no value is present.
+   * @return hash code value of the present value or 0 if no value is present
+   */
+  hashCode(): number;
+
+  /**
+   * {@inheritDoc}
+   *
+   *  Returns a non-empty string representation of this object suitable for
+   *  debugging. The exact presentation format is unspecified and may vary
+   *  between implementations and versions.
+   * @implSpec If a value is present the result must include its string&#xA; representation in the result. Empty and present instances must be&#xA; unambiguously differentiable.
+   * @return the string representation of this instance
+   */
+  toString(): string;
+};

package/types/java/util/OptionalDouble/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  empty: function empty() {},
+  of: function of() {},
+  getAsDouble: function getAsDouble() {},
+  isPresent: function isPresent() {},
+  ifPresent: function ifPresent() {},
+  orElse: function orElse() {},
+  orElseGet: function orElseGet() {},
+  orElseThrow: function orElseThrow() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;