@sitevision/api 2023.2.1 → 2023.2.2-beta.1

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

@@ -0,0 +1,303 @@
+import type { Object } from "../../lang/Object";
+import type { Iterator } from "../Iterator";
+
+import type { Collection } from "../Collection";
+
+import type { Spliterator } from "../Spliterator";
+
+/**
+ * A collection that contains no duplicate elements.  More formally, sets
+ *  contain no pair of elements <code>e1</code> and <code>e2</code> such that
+ *  <code>e1.equals(e2)</code>, and at most one null element.  As implied by
+ *  its name, this interface models the mathematical <i>set</i> abstraction.
+ *
+ *  <p>The <tt>Set</tt> interface places additional stipulations, beyond those
+ *  inherited from the <tt>Collection</tt> interface, on the contracts of all
+ *  constructors and on the contracts of the <tt>add</tt>, <tt>equals</tt> and
+ *  <tt>hashCode</tt> methods.  Declarations for other inherited methods are
+ *  also included here for convenience.  (The specifications accompanying these
+ *  declarations have been tailored to the <tt>Set</tt> interface, but they do
+ *  not contain any additional stipulations.)
+ *
+ *  <p>The additional stipulation on constructors is, not surprisingly,
+ *  that all constructors must create a set that contains no duplicate elements
+ *  (as defined above).
+ *
+ *  <p>Note: Great care must be exercised if mutable objects are used as set
+ *  elements.  The behavior of a set is not specified if the value of an object
+ *  is changed in a manner that affects <tt>equals</tt> comparisons while the
+ *  object is an element in the set.  A special case of this prohibition is
+ *  that it is not permissible for a set to contain itself as an element.
+ *
+ *  <p>Some set implementations have restrictions on the elements that
+ *  they may contain.  For example, some implementations prohibit null elements,
+ *  and some have restrictions on the types of their elements.  Attempting to
+ *  add an ineligible element throws an unchecked exception, typically
+ *  <tt>NullPointerException</tt> or <tt>ClassCastException</tt>.  Attempting
+ *  to query the presence of an ineligible element may throw an exception,
+ *  or it may simply return false; some implementations will exhibit the former
+ *  behavior and some will exhibit the latter.  More generally, attempting an
+ *  operation on an ineligible element whose completion would not result in
+ *  the insertion of an ineligible element into the set may throw an
+ *  exception or it may succeed, at the option of the implementation.
+ *  Such exceptions are marked as "optional" in the specification for this
+ *  interface.
+ *
+ *  <p>This interface is a member of the
+ *  <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ *  Java Collections Framework</a>.
+ * @param <E> the type of elements maintained by this set
+ * @author Josh Bloch
+ * @author Neal Gafter
+ * @see Collection
+ * @see List
+ * @see SortedSet
+ * @see HashSet
+ * @see TreeSet
+ * @see AbstractSet
+ * @see Collections#singleton(java.lang.Object)
+ * @see Collections#EMPTY_SET
+ * @since 1.2
+ */
+export type Set = Collection & {
+  /**
+   * Returns the number of elements in this set (its cardinality).  If this
+   *  set contains more than <tt>Integer.MAX_VALUE</tt> elements, returns
+   *  <tt>Integer.MAX_VALUE</tt>.
+   * @return the number of elements in this set (its cardinality)
+   */
+  size(): number;
+
+  /**
+   * Returns <tt>true</tt> if this set contains no elements.
+   * @return <tt>true</tt> if this set contains no elements
+   */
+  isEmpty(): boolean;
+
+  /**
+   * Returns <tt>true</tt> if this set contains the specified element.
+   *  More formally, returns <tt>true</tt> if and only if this set
+   *  contains an element <tt>e</tt> such that
+   *  <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>.
+   * @param o element whose presence in this set is to be tested
+   * @return <tt>true</tt> if this set contains the specified element
+   * @throws ClassCastException if the type of the specified element&#xA; is incompatible with this set&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if the specified element is null and this&#xA; set does not permit null elements&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   */
+  contains(o: unknown): boolean;
+
+  /**
+   * Returns an iterator over the elements in this set.  The elements are
+   *  returned in no particular order (unless this set is an instance of some
+   *  class that provides a guarantee).
+   * @return an iterator over the elements in this set
+   */
+  iterator(): Iterator;
+
+  /**
+   * Returns an array containing all of the elements in this set.
+   *  If this set makes any guarantees as to what order its elements
+   *  are returned by its iterator, this method must return the
+   *  elements in the same order.
+   *
+   *  <p>The returned array will be "safe" in that no references to it
+   *  are maintained by this set.  (In other words, this method must
+   *  allocate a new array even if this set is backed by an array).
+   *  The caller is thus free to modify the returned array.
+   *
+   *  <p>This method acts as bridge between array-based and collection-based
+   *  APIs.
+   * @return an array containing all the elements in this set
+   */
+  toArray(): unknown;
+
+  /**
+   * Returns an array containing all of the elements in this set; the
+   *  runtime type of the returned array is that of the specified array.
+   *  If the set fits in the specified array, it is returned therein.
+   *  Otherwise, a new array is allocated with the runtime type of the
+   *  specified array and the size of this set.
+   *
+   *  <p>If this set fits in the specified array with room to spare
+   *  (i.e., the array has more elements than this set), the element in
+   *  the array immediately following the end of the set is set to
+   *  <tt>null</tt>.  (This is useful in determining the length of this
+   *  set <i>only</i> if the caller knows that this set does not contain
+   *  any null elements.)
+   *
+   *  <p>If this set makes any guarantees as to what order its elements
+   *  are returned by its iterator, this method must return the elements
+   *  in the same order.
+   *
+   *  <p>Like the {@link #toArray()} method, this method acts as bridge between
+   *  array-based and collection-based APIs.  Further, this method allows
+   *  precise control over the runtime type of the output array, and may,
+   *  under certain circumstances, be used to save allocation costs.
+   *
+   *  <p>Suppose <tt>x</tt> is a set known to contain only strings.
+   *  The following code can be used to dump the set into a newly allocated
+   *  array of <tt>String</tt>:
+   *
+   *  <pre>
+   *      String[] y = x.toArray(new String[0]);</pre>
+   *
+   *  Note that <tt>toArray(new Object[0])</tt> is identical in function to
+   *  <tt>toArray()</tt>.
+   * @param a the array into which the elements of this set are to be&#xA; stored, if it is big enough; otherwise, a new array of the same&#xA; runtime type is allocated for this purpose.
+   * @return an array containing all the elements in this set
+   * @throws ArrayStoreException if the runtime type of the specified array&#xA; is not a supertype of the runtime type of every element in this&#xA; set
+   * @throws NullPointerException if the specified array is null
+   */
+  toArray(a: unknown[]): unknown;
+
+  /**
+   * Adds the specified element to this set if it is not already present
+   *  (optional operation).  More formally, adds the specified element
+   *  <tt>e</tt> to this set if the set contains no element <tt>e2</tt>
+   *  such that
+   *  <tt>(e==null&nbsp;?&nbsp;e2==null&nbsp;:&nbsp;e.equals(e2))</tt>.
+   *  If this set already contains the element, the call leaves the set
+   *  unchanged and returns <tt>false</tt>.  In combination with the
+   *  restriction on constructors, this ensures that sets never contain
+   *  duplicate elements.
+   *
+   *  <p>The stipulation above does not imply that sets must accept all
+   *  elements; sets may refuse to add any particular element, including
+   *  <tt>null</tt>, and throw an exception, as described in the
+   *  specification for {@link Collection#add Collection.add}.
+   *  Individual set implementations should clearly document any
+   *  restrictions on the elements that they may contain.
+   * @param e element to be added to this set
+   * @return <tt>true</tt> if this set did not already contain the specified&#xA; element
+   * @throws UnsupportedOperationException if the <tt>add</tt> operation&#xA; is not supported by this set
+   * @throws ClassCastException if the class of the specified element&#xA; prevents it from being added to this set
+   * @throws NullPointerException if the specified element is null and this&#xA; set does not permit null elements
+   * @throws IllegalArgumentException if some property of the specified element&#xA; prevents it from being added to this set
+   */
+  add(e: unknown): boolean;
+
+  /**
+   * Removes the specified element from this set if it is present
+   *  (optional operation).  More formally, removes an element <tt>e</tt>
+   *  such that
+   *  <tt>(o==null&nbsp;?&nbsp;e==null&nbsp;:&nbsp;o.equals(e))</tt>, if
+   *  this set contains such an element.  Returns <tt>true</tt> if this set
+   *  contained the element (or equivalently, if this set changed as a
+   *  result of the call).  (This set will not contain the element once the
+   *  call returns.)
+   * @param o object to be removed from this set, if present
+   * @return <tt>true</tt> if this set contained the specified element
+   * @throws ClassCastException if the type of the specified element&#xA; is incompatible with this set&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if the specified element is null and this&#xA; set does not permit null elements&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws UnsupportedOperationException if the <tt>remove</tt> operation&#xA; is not supported by this set
+   */
+  remove(o: unknown): boolean;
+
+  /**
+   * Returns <tt>true</tt> if this set contains all of the elements of the
+   *  specified collection.  If the specified collection is also a set, this
+   *  method returns <tt>true</tt> if it is a <i>subset</i> of this set.
+   * @param c collection to be checked for containment in this set
+   * @return <tt>true</tt> if this set contains all of the elements of the&#xA; specified collection
+   * @throws ClassCastException if the types of one or more elements&#xA; in the specified collection are incompatible with this&#xA; set&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if the specified collection contains one&#xA; or more null elements and this set does not permit null&#xA; elements&#xA; (<a href="Collection.html#optional-restrictions">optional</a>),&#xA; or if the specified collection is null
+   * @see #contains(Object)
+   */
+  containsAll(c: Collection | unknown[]): boolean;
+
+  /**
+   * Adds all of the elements in the specified collection to this set if
+   *  they're not already present (optional operation).  If the specified
+   *  collection is also a set, the <tt>addAll</tt> operation effectively
+   *  modifies this set so that its value is the <i>union</i> of the two
+   *  sets.  The behavior of this operation is undefined if the specified
+   *  collection is modified while the operation is in progress.
+   * @param c collection containing elements to be added to this set
+   * @return <tt>true</tt> if this set changed as a result of the call
+   * @throws UnsupportedOperationException if the <tt>addAll</tt> operation&#xA; is not supported by this set
+   * @throws ClassCastException if the class of an element of the&#xA; specified collection prevents it from being added to this set
+   * @throws NullPointerException if the specified collection contains one&#xA; or more null elements and this set does not permit null&#xA; elements, or if the specified collection is null
+   * @throws IllegalArgumentException if some property of an element of the&#xA; specified collection prevents it from being added to this set
+   * @see #add(Object)
+   */
+  addAll(c: Collection | unknown[]): boolean;
+
+  /**
+   * Retains only the elements in this set that are contained in the
+   *  specified collection (optional operation).  In other words, removes
+   *  from this set all of its elements that are not contained in the
+   *  specified collection.  If the specified collection is also a set, this
+   *  operation effectively modifies this set so that its value is the
+   *  <i>intersection</i> of the two sets.
+   * @param c collection containing elements to be retained in this set
+   * @return <tt>true</tt> if this set changed as a result of the call
+   * @throws UnsupportedOperationException if the <tt>retainAll</tt> operation&#xA; is not supported by this set
+   * @throws ClassCastException if the class of an element of this set&#xA; is incompatible with the specified collection&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if this set contains a null element and the&#xA; specified collection does not permit null elements&#xA; (<a href="Collection.html#optional-restrictions">optional</a>),&#xA; or if the specified collection is null
+   * @see #remove(Object)
+   */
+  retainAll(c: Collection | unknown[]): boolean;
+
+  /**
+   * Removes from this set all of its elements that are contained in the
+   *  specified collection (optional operation).  If the specified
+   *  collection is also a set, this operation effectively modifies this
+   *  set so that its value is the <i>asymmetric set difference</i> of
+   *  the two sets.
+   * @param c collection containing elements to be removed from this set
+   * @return <tt>true</tt> if this set changed as a result of the call
+   * @throws UnsupportedOperationException if the <tt>removeAll</tt> operation&#xA; is not supported by this set
+   * @throws ClassCastException if the class of an element of this set&#xA; is incompatible with the specified collection&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if this set contains a null element and the&#xA; specified collection does not permit null elements&#xA; (<a href="Collection.html#optional-restrictions">optional</a>),&#xA; or if the specified collection is null
+   * @see #remove(Object)
+   * @see #contains(Object)
+   */
+  removeAll(c: Collection | unknown[]): boolean;
+
+  /**
+   * Removes all of the elements from this set (optional operation).
+   *  The set will be empty after this call returns.
+   * @throws UnsupportedOperationException if the <tt>clear</tt> method&#xA; is not supported by this set
+   */
+  clear(): void;
+
+  /**
+   * Compares the specified object with this set for equality.  Returns
+   *  <tt>true</tt> if the specified object is also a set, the two sets
+   *  have the same size, and every member of the specified set is
+   *  contained in this set (or equivalently, every member of this set is
+   *  contained in the specified set).  This definition ensures that the
+   *  equals method works properly across different implementations of the
+   *  set interface.
+   * @param o object to be compared for equality with this set
+   * @return <tt>true</tt> if the specified object is equal to this set
+   */
+  equals(o: unknown): boolean;
+
+  /**
+   * Returns the hash code value for this set.  The hash code of a set is
+   *  defined to be the sum of the hash codes of the elements in the set,
+   *  where the hash code of a <tt>null</tt> element is defined to be zero.
+   *  This ensures that <tt>s1.equals(s2)</tt> implies that
+   *  <tt>s1.hashCode()==s2.hashCode()</tt> for any two sets <tt>s1</tt>
+   *  and <tt>s2</tt>, as required by the general contract of
+   *  {@link Object#hashCode}.
+   * @return the hash code value for this set
+   * @see Object#equals(Object)
+   * @see Set#equals(Object)
+   */
+  hashCode(): number;
+
+  /**
+   * Creates a {@code Spliterator} over the elements in this set.
+   *
+   *  <p>The {@code Spliterator} reports {@link Spliterator#DISTINCT}.
+   *  Implementations should document the reporting of additional
+   *  characteristic values.
+   * @implSpec The default implementation creates a&#xA; <em><a href="Spliterator.html#binding">late-binding</a></em> spliterator&#xA; from the set's {@code Iterator}. The spliterator inherits the&#xA; <em>fail-fast</em> properties of the set's iterator.&#xA; <p>&#xA; The created {@code Spliterator} additionally reports&#xA; {@link Spliterator#SIZED}.
+   * @implNote The created {@code Spliterator} additionally reports&#xA; {@link Spliterator#SUBSIZED}.
+   * @return a {@code Spliterator} over the elements in this set
+   * @since 1.8
+   */
+  spliterator(): Spliterator;
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  size: function size() {},
+  isEmpty: function isEmpty() {},
+  contains: function contains() {},
+  iterator: function iterator() {},
+  toArray: function toArray() {},
+  add: function add() {},
+  remove: function remove() {},
+  containsAll: function containsAll() {},
+  addAll: function addAll() {},
+  retainAll: function retainAll() {},
+  removeAll: function removeAll() {},
+  clear: function clear() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  spliterator: function spliterator() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,218 @@
+import type { Comparator } from "../Comparator";
+
+import type { Set } from "../Set";
+import type { Collection } from "../Collection";
+import type { Map } from "../Map";
+
+/**
+ * A {@link Map} that further provides a <em>total ordering</em> on its keys.
+ *  The map is ordered according to the {@linkplain Comparable natural
+ *  ordering} of its keys, or by a {@link Comparator} typically
+ *  provided at sorted map creation time.  This order is reflected when
+ *  iterating over the sorted map's collection views (returned by the
+ *  {@code entrySet}, {@code keySet} and {@code values} methods).
+ *  Several additional operations are provided to take advantage of the
+ *  ordering.  (This interface is the map analogue of {@link SortedSet}.)
+ *
+ *  <p>All keys inserted into a sorted map must implement the {@code Comparable}
+ *  interface (or be accepted by the specified comparator).  Furthermore, all
+ *  such keys must be <em>mutually comparable</em>: {@code k1.compareTo(k2)} (or
+ *  {@code comparator.compare(k1, k2)}) must not throw a
+ *  {@code ClassCastException} for any keys {@code k1} and {@code k2} in
+ *  the sorted map.  Attempts to violate this restriction will cause the
+ *  offending method or constructor invocation to throw a
+ *  {@code ClassCastException}.
+ *
+ *  <p>Note that the ordering maintained by a sorted map (whether or not an
+ *  explicit comparator is provided) must be <em>consistent with equals</em> if
+ *  the sorted map is to correctly implement the {@code Map} interface.  (See
+ *  the {@code Comparable} interface or {@code Comparator} interface for a
+ *  precise definition of <em>consistent with equals</em>.)  This is so because
+ *  the {@code Map} interface is defined in terms of the {@code equals}
+ *  operation, but a sorted map performs all key comparisons using its
+ *  {@code compareTo} (or {@code compare}) method, so two keys that are
+ *  deemed equal by this method are, from the standpoint of the sorted map,
+ *  equal.  The behavior of a tree map <em>is</em> well-defined even if its
+ *  ordering is inconsistent with equals; it just fails to obey the general
+ *  contract of the {@code Map} interface.
+ *
+ *  <p>All general-purpose sorted map implementation classes should provide four
+ *  "standard" constructors. It is not possible to enforce this recommendation
+ *  though as required constructors cannot be specified by interfaces. The
+ *  expected "standard" constructors for all sorted map implementations are:
+ *  <ol>
+ *    <li>A void (no arguments) constructor, which creates an empty sorted map
+ *    sorted according to the natural ordering of its keys.</li>
+ *    <li>A constructor with a single argument of type {@code Comparator}, which
+ *    creates an empty sorted map sorted according to the specified comparator.</li>
+ *    <li>A constructor with a single argument of type {@code Map}, which creates
+ *    a new map with the same key-value mappings as its argument, sorted
+ *    according to the keys' natural ordering.</li>
+ *    <li>A constructor with a single argument of type {@code SortedMap}, which
+ *    creates a new sorted map with the same key-value mappings and the same
+ *    ordering as the input sorted map.</li>
+ *  </ol>
+ *
+ *  <p><strong>Note</strong>: several methods return submaps with restricted key
+ *  ranges. Such ranges are <em>half-open</em>, that is, they include their low
+ *  endpoint but not their high endpoint (where applicable).  If you need a
+ *  <em>closed range</em> (which includes both endpoints), and the key type
+ *  allows for calculation of the successor of a given key, merely request
+ *  the subrange from {@code lowEndpoint} to
+ *  {@code successor(highEndpoint)}.  For example, suppose that {@code m}
+ *  is a map whose keys are strings.  The following idiom obtains a view
+ *  containing all of the key-value mappings in {@code m} whose keys are
+ *  between {@code low} and {@code high}, inclusive:<pre>
+ *    SortedMap&lt;String, V&gt; sub = m.subMap(low, high+"\0");</pre>
+ *
+ *  A similar technique can be used to generate an <em>open range</em>
+ *  (which contains neither endpoint).  The following idiom obtains a
+ *  view containing all of the key-value mappings in {@code m} whose keys
+ *  are between {@code low} and {@code high}, exclusive:<pre>
+ *    SortedMap&lt;String, V&gt; sub = m.subMap(low+"\0", high);</pre>
+ *
+ *  <p>This interface is a member of the
+ *  <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ *  Java Collections Framework</a>.
+ * @param <K> the type of keys maintained by this map
+ * @param <V> the type of mapped values
+ * @author Josh Bloch
+ * @see Map
+ * @see TreeMap
+ * @see SortedSet
+ * @see Comparator
+ * @see Comparable
+ * @see Collection
+ * @see ClassCastException
+ * @since 1.2
+ */
+export type SortedMap = Map & {
+  /**
+   * Returns the comparator used to order the keys in this map, or
+   *  {@code null} if this map uses the {@linkplain Comparable
+   *  natural ordering} of its keys.
+   * @return the comparator used to order the keys in this map,&#xA; or {@code null} if this map uses the natural ordering&#xA; of its keys
+   */
+  comparator(): Comparator;
+
+  /**
+   * Returns a view of the portion of this map whose keys range from
+   *  {@code fromKey}, inclusive, to {@code toKey}, exclusive.  (If
+   *  {@code fromKey} and {@code toKey} are equal, the returned map
+   *  is empty.)  The returned map is backed by this map, so changes
+   *  in the returned map are reflected in this map, and vice-versa.
+   *  The returned map supports all optional map operations that this
+   *  map supports.
+   *
+   *  <p>The returned map will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert a key outside its range.
+   * @param fromKey low endpoint (inclusive) of the keys in the returned map
+   * @param toKey high endpoint (exclusive) of the keys in the returned map
+   * @return a view of the portion of this map whose keys range from&#xA; {@code fromKey}, inclusive, to {@code toKey}, exclusive
+   * @throws ClassCastException if {@code fromKey} and {@code toKey}&#xA; cannot be compared to one another using this map's comparator&#xA; (or, if the map has no comparator, using natural ordering).&#xA; Implementations may, but are not required to, throw this&#xA; exception if {@code fromKey} or {@code toKey}&#xA; cannot be compared to keys currently in the map.
+   * @throws NullPointerException if {@code fromKey} or {@code toKey}&#xA; is null and this map does not permit null keys
+   * @throws IllegalArgumentException if {@code fromKey} is greater than&#xA; {@code toKey}; or if this map itself has a restricted&#xA; range, and {@code fromKey} or {@code toKey} lies&#xA; outside the bounds of the range
+   */
+  subMap(fromKey: unknown, toKey: unknown): SortedMap;
+
+  /**
+   * Returns a view of the portion of this map whose keys are
+   *  strictly less than {@code toKey}.  The returned map is backed
+   *  by this map, so changes in the returned map are reflected in
+   *  this map, and vice-versa.  The returned map supports all
+   *  optional map operations that this map supports.
+   *
+   *  <p>The returned map will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert a key outside its range.
+   * @param toKey high endpoint (exclusive) of the keys in the returned map
+   * @return a view of the portion of this map whose keys are strictly&#xA; less than {@code toKey}
+   * @throws ClassCastException if {@code toKey} is not compatible&#xA; with this map's comparator (or, if the map has no comparator,&#xA; if {@code toKey} does not implement {@link Comparable}).&#xA; Implementations may, but are not required to, throw this&#xA; exception if {@code toKey} cannot be compared to keys&#xA; currently in the map.
+   * @throws NullPointerException if {@code toKey} is null and&#xA; this map does not permit null keys
+   * @throws IllegalArgumentException if this map itself has a&#xA; restricted range, and {@code toKey} lies outside the&#xA; bounds of the range
+   */
+  headMap(toKey: unknown): SortedMap;
+
+  /**
+   * Returns a view of the portion of this map whose keys are
+   *  greater than or equal to {@code fromKey}.  The returned map is
+   *  backed by this map, so changes in the returned map are
+   *  reflected in this map, and vice-versa.  The returned map
+   *  supports all optional map operations that this map supports.
+   *
+   *  <p>The returned map will throw an {@code IllegalArgumentException}
+   *  on an attempt to insert a key outside its range.
+   * @param fromKey low endpoint (inclusive) of the keys in the returned map
+   * @return a view of the portion of this map whose keys are greater&#xA; than or equal to {@code fromKey}
+   * @throws ClassCastException if {@code fromKey} is not compatible&#xA; with this map's comparator (or, if the map has no comparator,&#xA; if {@code fromKey} does not implement {@link Comparable}).&#xA; Implementations may, but are not required to, throw this&#xA; exception if {@code fromKey} cannot be compared to keys&#xA; currently in the map.
+   * @throws NullPointerException if {@code fromKey} is null and&#xA; this map does not permit null keys
+   * @throws IllegalArgumentException if this map itself has a&#xA; restricted range, and {@code fromKey} lies outside the&#xA; bounds of the range
+   */
+  tailMap(fromKey: unknown): SortedMap;
+
+  /**
+   * Returns the first (lowest) key currently in this map.
+   * @return the first (lowest) key currently in this map
+   * @throws NoSuchElementException if this map is empty
+   */
+  firstKey(): unknown;
+
+  /**
+   * Returns the last (highest) key currently in this map.
+   * @return the last (highest) key currently in this map
+   * @throws NoSuchElementException if this map is empty
+   */
+  lastKey(): unknown;
+
+  /**
+   * Returns a {@link Set} view of the keys contained in this map.
+   *  The set's iterator returns the keys in ascending order.
+   *  The set is backed by the map, so changes to the map are
+   *  reflected in the set, and vice-versa.  If the map is modified
+   *  while an iteration over the set is in progress (except through
+   *  the iterator's own {@code remove} operation), the results of
+   *  the iteration are undefined.  The set supports element removal,
+   *  which removes the corresponding mapping from the map, via the
+   *  {@code Iterator.remove}, {@code Set.remove},
+   *  {@code removeAll}, {@code retainAll}, and {@code clear}
+   *  operations.  It does not support the {@code add} or {@code addAll}
+   *  operations.
+   * @return a set view of the keys contained in this map, sorted in&#xA; ascending order
+   */
+  keySet(): Set;
+
+  /**
+   * Returns a {@link Collection} view of the values contained in this map.
+   *  The collection's iterator returns the values in ascending order
+   *  of the corresponding keys.
+   *  The collection is backed by the map, so changes to the map are
+   *  reflected in the collection, and vice-versa.  If the map is
+   *  modified while an iteration over the collection is in progress
+   *  (except through the iterator's own {@code remove} operation),
+   *  the results of the iteration are undefined.  The collection
+   *  supports element removal, which removes the corresponding
+   *  mapping from the map, via the {@code Iterator.remove},
+   *  {@code Collection.remove}, {@code removeAll},
+   *  {@code retainAll} and {@code clear} operations.  It does not
+   *  support the {@code add} or {@code addAll} operations.
+   * @return a collection view of the values contained in this map,&#xA; sorted in ascending key order
+   */
+  values(): Collection;
+
+  /**
+   * Returns a {@link Set} view of the mappings contained in this map.
+   *  The set's iterator returns the entries in ascending key order.
+   *  The set is backed by the map, so changes to the map are
+   *  reflected in the set, and vice-versa.  If the map is modified
+   *  while an iteration over the set is in progress (except through
+   *  the iterator's own {@code remove} operation, or through the
+   *  {@code setValue} operation on a map entry returned by the
+   *  iterator) the results of the iteration are undefined.  The set
+   *  supports element removal, which removes the corresponding
+   *  mapping from the map, via the {@code Iterator.remove},
+   *  {@code Set.remove}, {@code removeAll}, {@code retainAll} and
+   *  {@code clear} operations.  It does not support the
+   *  {@code add} or {@code addAll} operations.
+   * @return a set view of the mappings contained in this map,&#xA; sorted in ascending key order
+   */
+  entrySet(): Set;
+};

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

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  comparator: function comparator() {},
+  subMap: function subMap() {},
+  headMap: function headMap() {},
+  tailMap: function tailMap() {},
+  firstKey: function firstKey() {},
+  lastKey: function lastKey() {},
+  keySet: function keySet() {},
+  values: function values() {},
+  entrySet: function entrySet() {}
+};
+exports["default"] = _default;