@sitevision/api 2023.2.1 → 2023.2.2-beta.2

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

@@ -0,0 +1,17 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  accept: function accept() {},
+  combine: function combine() {},
+  getCount: function getCount() {},
+  getSum: function getSum() {},
+  getMin: function getMin() {},
+  getMax: function getMax() {},
+  getAverage: function getAverage() {},
+  toString: function toString() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,65 @@
+import type { Consumer } from "../function/Consumer";
+
+/**
+ * An iterator over a collection.  {@code Iterator} takes the place of
+ *  {@link Enumeration} in the Java Collections Framework.  Iterators
+ *  differ from enumerations in two ways:
+ *
+ *  <ul>
+ *       <li> Iterators allow the caller to remove elements from the
+ *            underlying collection during the iteration with well-defined
+ *            semantics.
+ *       <li> Method names have been improved.
+ *  </ul>
+ *
+ *  <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 returned by this iterator
+ * @author Josh Bloch
+ * @see Collection
+ * @see ListIterator
+ * @see Iterable
+ * @since 1.2
+ */
+export type Iterator = {
+  /**
+   * Returns {@code true} if the iteration has more elements.
+   *  (In other words, returns {@code true} if {@link #next} would
+   *  return an element rather than throwing an exception.)
+   * @return {@code true} if the iteration has more elements
+   */
+  hasNext(): boolean;
+
+  /**
+   * Returns the next element in the iteration.
+   * @return the next element in the iteration
+   * @throws NoSuchElementException if the iteration has no more elements
+   */
+  next(): unknown;
+
+  /**
+   * Removes from the underlying collection the last element returned
+   *  by this iterator (optional operation).  This method can be called
+   *  only once per call to {@link #next}.  The behavior of an iterator
+   *  is unspecified if the underlying collection is modified while the
+   *  iteration is in progress in any way other than by calling this
+   *  method.
+   * @implSpec The default implementation throws an instance of&#xA; {@link UnsupportedOperationException} and performs no other action.
+   * @throws UnsupportedOperationException if the {@code remove}&#xA; operation is not supported by this iterator
+   * @throws IllegalStateException if the {@code next} method has not&#xA; yet been called, or the {@code remove} method has already&#xA; been called after the last call to the {@code next}&#xA; method
+   */
+  remove(): void;
+
+  /**
+   * Performs the given action for each remaining element until all elements
+   *  have been processed or the action throws an exception.  Actions are
+   *  performed in the order of iteration, if that order is specified.
+   *  Exceptions thrown by the action are relayed to the caller.
+   * @implSpec <p>The default implementation behaves as if:&#xA; <pre>{@code&#xA; while (hasNext())&#xA; action.accept(next());&#xA; }</pre>
+   * @param action The action to be performed for each element
+   * @throws NullPointerException if the specified action is null
+   * @since 1.8
+   */
+  forEachRemaining(action: Consumer): void;
+};

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

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  hasNext: function hasNext() {},
+  next: function next() {},
+  remove: function remove() {},
+  forEachRemaining: function forEachRemaining() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,503 @@
+import type { Object } from "../../lang/Object";
+import type { Iterator } from "../Iterator";
+
+import type { Collection } from "../Collection";
+import type { UnaryOperator } from "../function/UnaryOperator";
+
+import type { Comparator } from "../Comparator";
+import type { ListIterator } from "../ListIterator";
+import type { Spliterator } from "../Spliterator";
+
+/**
+ * An ordered collection (also known as a <i>sequence</i>).  The user of this
+ *  interface has precise control over where in the list each element is
+ *  inserted.  The user can access elements by their integer index (position in
+ *  the list), and search for elements in the list.<p>
+ *
+ *  Unlike sets, lists typically allow duplicate elements.  More formally,
+ *  lists typically allow pairs of elements <tt>e1</tt> and <tt>e2</tt>
+ *  such that <tt>e1.equals(e2)</tt>, and they typically allow multiple
+ *  null elements if they allow null elements at all.  It is not inconceivable
+ *  that someone might wish to implement a list that prohibits duplicates, by
+ *  throwing runtime exceptions when the user attempts to insert them, but we
+ *  expect this usage to be rare.<p>
+ *
+ *  The <tt>List</tt> interface places additional stipulations, beyond those
+ *  specified in the <tt>Collection</tt> interface, on the contracts of the
+ *  <tt>iterator</tt>, <tt>add</tt>, <tt>remove</tt>, <tt>equals</tt>, and
+ *  <tt>hashCode</tt> methods.  Declarations for other inherited methods are
+ *  also included here for convenience.<p>
+ *
+ *  The <tt>List</tt> interface provides four methods for positional (indexed)
+ *  access to list elements.  Lists (like Java arrays) are zero based.  Note
+ *  that these operations may execute in time proportional to the index value
+ *  for some implementations (the <tt>LinkedList</tt> class, for
+ *  example). Thus, iterating over the elements in a list is typically
+ *  preferable to indexing through it if the caller does not know the
+ *  implementation.<p>
+ *
+ *  The <tt>List</tt> interface provides a special iterator, called a
+ *  <tt>ListIterator</tt>, that allows element insertion and replacement, and
+ *  bidirectional access in addition to the normal operations that the
+ *  <tt>Iterator</tt> interface provides.  A method is provided to obtain a
+ *  list iterator that starts at a specified position in the list.<p>
+ *
+ *  The <tt>List</tt> interface provides two methods to search for a specified
+ *  object.  From a performance standpoint, these methods should be used with
+ *  caution.  In many implementations they will perform costly linear
+ *  searches.<p>
+ *
+ *  The <tt>List</tt> interface provides two methods to efficiently insert and
+ *  remove multiple elements at an arbitrary point in the list.<p>
+ *
+ *  Note: While it is permissible for lists to contain themselves as elements,
+ *  extreme caution is advised: the <tt>equals</tt> and <tt>hashCode</tt>
+ *  methods are no longer well defined on such a list.
+ *
+ *  <p>Some list 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 list 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 in this list
+ * @author Josh Bloch
+ * @author Neal Gafter
+ * @see Collection
+ * @see Set
+ * @see ArrayList
+ * @see LinkedList
+ * @see Vector
+ * @see Arrays#asList(Object[])
+ * @see Collections#nCopies(int, Object)
+ * @see Collections#EMPTY_LIST
+ * @see AbstractList
+ * @see AbstractSequentialList
+ * @since 1.2
+ */
+export type List = Collection & {
+  /**
+   * Returns the number of elements in this list.  If this list contains
+   *  more than <tt>Integer.MAX_VALUE</tt> elements, returns
+   *  <tt>Integer.MAX_VALUE</tt>.
+   * @return the number of elements in this list
+   */
+  size(): number;
+
+  /**
+   * Returns <tt>true</tt> if this list contains no elements.
+   * @return <tt>true</tt> if this list contains no elements
+   */
+  isEmpty(): boolean;
+
+  /**
+   * Returns <tt>true</tt> if this list contains the specified element.
+   *  More formally, returns <tt>true</tt> if and only if this list contains
+   *  at least one 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 list is to be tested
+   * @return <tt>true</tt> if this list contains the specified element
+   * @throws ClassCastException if the type of the specified element&#xA; is incompatible with this list&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if the specified element is null and this&#xA; list 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 list in proper sequence.
+   * @return an iterator over the elements in this list in proper sequence
+   */
+  iterator(): Iterator;
+
+  /**
+   * Returns an array containing all of the elements in this list in proper
+   *  sequence (from first to last element).
+   *
+   *  <p>The returned array will be "safe" in that no references to it are
+   *  maintained by this list.  (In other words, this method must
+   *  allocate a new array even if this list 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 of the elements in this list in proper&#xA; sequence
+   * @see Arrays#asList(Object[])
+   */
+  toArray(): unknown;
+
+  /**
+   * Returns an array containing all of the elements in this list in
+   *  proper sequence (from first to last element); the runtime type of
+   *  the returned array is that of the specified array.  If the list 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 list.
+   *
+   *  <p>If the list fits in the specified array with room to spare (i.e.,
+   *  the array has more elements than the list), the element in the array
+   *  immediately following the end of the list is set to <tt>null</tt>.
+   *  (This is useful in determining the length of the list <i>only</i> if
+   *  the caller knows that the list does not contain any null elements.)
+   *
+   *  <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 list known to contain only strings.
+   *  The following code can be used to dump the list into a newly
+   *  allocated array of <tt>String</tt>:
+   *
+   *  <pre>{@code
+   *      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 list are to&#xA; be stored, if it is big enough; otherwise, a new array of the&#xA; same runtime type is allocated for this purpose.
+   * @return an array containing the elements of this list
+   * @throws ArrayStoreException if the runtime type of the specified array&#xA; is not a supertype of the runtime type of every element in&#xA; this list
+   * @throws NullPointerException if the specified array is null
+   */
+  toArray(a: unknown[]): unknown;
+
+  /**
+   * Appends the specified element to the end of this list (optional
+   *  operation).
+   *
+   *  <p>Lists that support this operation may place limitations on what
+   *  elements may be added to this list.  In particular, some
+   *  lists will refuse to add null elements, and others will impose
+   *  restrictions on the type of elements that may be added.  List
+   *  classes should clearly specify in their documentation any restrictions
+   *  on what elements may be added.
+   * @param e element to be appended to this list
+   * @return <tt>true</tt> (as specified by {@link Collection#add})
+   * @throws UnsupportedOperationException if the <tt>add</tt> operation&#xA; is not supported by this list
+   * @throws ClassCastException if the class of the specified element&#xA; prevents it from being added to this list
+   * @throws NullPointerException if the specified element is null and this&#xA; list does not permit null elements
+   * @throws IllegalArgumentException if some property of this element&#xA; prevents it from being added to this list
+   */
+  add(e: unknown): boolean;
+
+  /**
+   * Removes the first occurrence of the specified element from this list,
+   *  if it is present (optional operation).  If this list does not contain
+   *  the element, it is unchanged.  More formally, removes the element with
+   *  the lowest index <tt>i</tt> such that
+   *  <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
+   *  (if such an element exists).  Returns <tt>true</tt> if this list
+   *  contained the specified element (or equivalently, if this list changed
+   *  as a result of the call).
+   * @param o element to be removed from this list, if present
+   * @return <tt>true</tt> if this list contained the specified element
+   * @throws ClassCastException if the type of the specified element&#xA; is incompatible with this list&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if the specified element is null and this&#xA; list 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 list
+   */
+  remove(o: unknown): boolean;
+
+  /**
+   * Returns <tt>true</tt> if this list contains all of the elements of the
+   *  specified collection.
+   * @param c collection to be checked for containment in this list
+   * @return <tt>true</tt> if this list 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; list&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if the specified collection contains one&#xA; or more null elements and this list 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;
+
+  /**
+   * Appends all of the elements in the specified collection to the end of
+   *  this list, in the order that they are returned by the specified
+   *  collection's iterator (optional operation).  The behavior of this
+   *  operation is undefined if the specified collection is modified while
+   *  the operation is in progress.  (Note that this will occur if the
+   *  specified collection is this list, and it's nonempty.)
+   * @param c collection containing elements to be added to this list
+   * @return <tt>true</tt> if this list changed as a result of the call
+   * @throws UnsupportedOperationException if the <tt>addAll</tt> operation&#xA; is not supported by this list
+   * @throws ClassCastException if the class of an element of the specified&#xA; collection prevents it from being added to this list
+   * @throws NullPointerException if the specified collection contains one&#xA; or more null elements and this list 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 list
+   * @see #add(Object)
+   */
+  addAll(c: Collection | unknown[]): boolean;
+
+  /**
+   * Inserts all of the elements in the specified collection into this
+   *  list at the specified position (optional operation).  Shifts the
+   *  element currently at that position (if any) and any subsequent
+   *  elements to the right (increases their indices).  The new elements
+   *  will appear in this list in the order that they are returned by the
+   *  specified collection's iterator.  The behavior of this operation is
+   *  undefined if the specified collection is modified while the
+   *  operation is in progress.  (Note that this will occur if the specified
+   *  collection is this list, and it's nonempty.)
+   * @param index index at which to insert the first element from the&#xA; specified collection
+   * @param c collection containing elements to be added to this list
+   * @return <tt>true</tt> if this list changed as a result of the call
+   * @throws UnsupportedOperationException if the <tt>addAll</tt> operation&#xA; is not supported by this list
+   * @throws ClassCastException if the class of an element of the specified&#xA; collection prevents it from being added to this list
+   * @throws NullPointerException if the specified collection contains one&#xA; or more null elements and this list 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 list
+   * @throws IndexOutOfBoundsException if the index is out of range&#xA; (<tt>index &lt; 0 || index &gt; size()</tt>)
+   */
+  addAll(index: number, c: Collection | unknown[]): boolean;
+
+  /**
+   * Removes from this list all of its elements that are contained in the
+   *  specified collection (optional operation).
+   * @param c collection containing elements to be removed from this list
+   * @return <tt>true</tt> if this list changed as a result of the call
+   * @throws UnsupportedOperationException if the <tt>removeAll</tt> operation&#xA; is not supported by this list
+   * @throws ClassCastException if the class of an element of this list&#xA; is incompatible with the specified collection&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if this list 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;
+
+  /**
+   * Retains only the elements in this list that are contained in the
+   *  specified collection (optional operation).  In other words, removes
+   *  from this list all of its elements that are not contained in the
+   *  specified collection.
+   * @param c collection containing elements to be retained in this list
+   * @return <tt>true</tt> if this list changed as a result of the call
+   * @throws UnsupportedOperationException if the <tt>retainAll</tt> operation&#xA; is not supported by this list
+   * @throws ClassCastException if the class of an element of this list&#xA; is incompatible with the specified collection&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if this list 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)
+   */
+  retainAll(c: Collection | unknown[]): boolean;
+
+  /**
+   * Replaces each element of this list with the result of applying the
+   *  operator to that element.  Errors or runtime exceptions thrown by
+   *  the operator are relayed to the caller.
+   * @implSpec The default implementation is equivalent to, for this {@code list}:&#xA; <pre>{@code&#xA; final ListIterator<E> li = list.listIterator();&#xA; while (li.hasNext()) {&#xA; li.set(operator.apply(li.next()));&#xA; }&#xA; }</pre>&#xA;&#xA; If the list's list-iterator does not support the {@code set} operation&#xA; then an {@code UnsupportedOperationException} will be thrown when&#xA; replacing the first element.
+   * @param operator the operator to apply to each element
+   * @throws UnsupportedOperationException if this list is unmodifiable.&#xA; Implementations may throw this exception if an element&#xA; cannot be replaced or if, in general, modification is not&#xA; supported
+   * @throws NullPointerException if the specified operator is null or&#xA; if the operator result is a null value and this list does&#xA; not permit null elements&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @since 1.8
+   */
+  replaceAll(operator: UnaryOperator): void;
+
+  /**
+   * Sorts this list according to the order induced by the specified
+   *  {@link Comparator}.
+   *
+   *  <p>All elements in this list must be <i>mutually comparable</i> using the
+   *  specified comparator (that is, {@code c.compare(e1, e2)} must not throw
+   *  a {@code ClassCastException} for any elements {@code e1} and {@code e2}
+   *  in the list).
+   *
+   *  <p>If the specified comparator is {@code null} then all elements in this
+   *  list must implement the {@link Comparable} interface and the elements'
+   *  {@linkplain Comparable natural ordering} should be used.
+   *
+   *  <p>This list must be modifiable, but need not be resizable.
+   * @implSpec The default implementation obtains an array containing all elements in&#xA; this list, sorts the array, and iterates over this list resetting each&#xA; element from the corresponding position in the array. (This avoids the&#xA; n<sup>2</sup> log(n) performance that would result from attempting&#xA; to sort a linked list in place.)
+   * @implNote This implementation is a stable, adaptive, iterative mergesort that&#xA; requires far fewer than n lg(n) comparisons when the input array is&#xA; partially sorted, while offering the performance of a traditional&#xA; mergesort when the input array is randomly ordered. If the input array&#xA; is nearly sorted, the implementation requires approximately n&#xA; comparisons. Temporary storage requirements vary from a small constant&#xA; for nearly sorted input arrays to n/2 object references for randomly&#xA; ordered input arrays.&#xA;&#xA; <p>The implementation takes equal advantage of ascending and&#xA; descending order in its input array, and can take advantage of&#xA; ascending and descending order in different parts of the same&#xA; input array. It is well-suited to merging two or more sorted arrays:&#xA; simply concatenate the arrays and sort the resulting array.&#xA;&#xA; <p>The implementation was adapted from Tim Peters's list sort for Python&#xA; (<a href="http://svn.python.org/projects/python/trunk/Objects/listsort.txt">&#xA; TimSort</a>). It uses techniques from Peter McIlroy's "Optimistic&#xA; Sorting and Information Theoretic Complexity", in Proceedings of the&#xA; Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,&#xA; January 1993.
+   * @param c the {@code Comparator} used to compare list elements.&#xA; A {@code null} value indicates that the elements'&#xA; {@linkplain Comparable natural ordering} should be used
+   * @throws ClassCastException if the list contains elements that are not&#xA; <i>mutually comparable</i> using the specified comparator
+   * @throws UnsupportedOperationException if the list's list-iterator does&#xA; not support the {@code set} operation
+   * @throws IllegalArgumentException&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)&#xA; if the comparator is found to violate the {@link Comparator}&#xA; contract
+   * @since 1.8
+   */
+  sort(c: Comparator): void;
+
+  /**
+   * Removes all of the elements from this list (optional operation).
+   *  The list will be empty after this call returns.
+   * @throws UnsupportedOperationException if the <tt>clear</tt> operation&#xA; is not supported by this list
+   */
+  clear(): void;
+
+  /**
+   * Compares the specified object with this list for equality.  Returns
+   *  <tt>true</tt> if and only if the specified object is also a list, both
+   *  lists have the same size, and all corresponding pairs of elements in
+   *  the two lists are <i>equal</i>.  (Two elements <tt>e1</tt> and
+   *  <tt>e2</tt> are <i>equal</i> if <tt>(e1==null ? e2==null :
+   *  e1.equals(e2))</tt>.)  In other words, two lists are defined to be
+   *  equal if they contain the same elements in the same order.  This
+   *  definition ensures that the equals method works properly across
+   *  different implementations of the <tt>List</tt> interface.
+   * @param o the object to be compared for equality with this list
+   * @return <tt>true</tt> if the specified object is equal to this list
+   */
+  equals(o: unknown): boolean;
+
+  /**
+   * Returns the hash code value for this list.  The hash code of a list
+   *  is defined to be the result of the following calculation:
+   *  <pre>{@code
+   *      int hashCode = 1;
+   *      for (E e : list)
+   *          hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
+   *  }</pre>
+   *  This ensures that <tt>list1.equals(list2)</tt> implies that
+   *  <tt>list1.hashCode()==list2.hashCode()</tt> for any two lists,
+   *  <tt>list1</tt> and <tt>list2</tt>, as required by the general
+   *  contract of {@link Object#hashCode}.
+   * @return the hash code value for this list
+   * @see Object#equals(Object)
+   * @see #equals(Object)
+   */
+  hashCode(): number;
+
+  /**
+   * Returns the element at the specified position in this list.
+   * @param index index of the element to return
+   * @return the element at the specified position in this list
+   * @throws IndexOutOfBoundsException if the index is out of range&#xA; (<tt>index &lt; 0 || index &gt;= size()</tt>)
+   */
+  get(index: number): unknown;
+
+  /**
+   * Replaces the element at the specified position in this list with the
+   *  specified element (optional operation).
+   * @param index index of the element to replace
+   * @param element element to be stored at the specified position
+   * @return the element previously at the specified position
+   * @throws UnsupportedOperationException if the <tt>set</tt> operation&#xA; is not supported by this list
+   * @throws ClassCastException if the class of the specified element&#xA; prevents it from being added to this list
+   * @throws NullPointerException if the specified element is null and&#xA; this list does not permit null elements
+   * @throws IllegalArgumentException if some property of the specified&#xA; element prevents it from being added to this list
+   * @throws IndexOutOfBoundsException if the index is out of range&#xA; (<tt>index &lt; 0 || index &gt;= size()</tt>)
+   */
+  set(index: number, element: unknown): unknown;
+
+  /**
+   * Inserts the specified element at the specified position in this list
+   *  (optional operation).  Shifts the element currently at that position
+   *  (if any) and any subsequent elements to the right (adds one to their
+   *  indices).
+   * @param index index at which the specified element is to be inserted
+   * @param element element to be inserted
+   * @throws UnsupportedOperationException if the <tt>add</tt> operation&#xA; is not supported by this list
+   * @throws ClassCastException if the class of the specified element&#xA; prevents it from being added to this list
+   * @throws NullPointerException if the specified element is null and&#xA; this list does not permit null elements
+   * @throws IllegalArgumentException if some property of the specified&#xA; element prevents it from being added to this list
+   * @throws IndexOutOfBoundsException if the index is out of range&#xA; (<tt>index &lt; 0 || index &gt; size()</tt>)
+   */
+  add(index: number, element: unknown): void;
+
+  /**
+   * Removes the element at the specified position in this list (optional
+   *  operation).  Shifts any subsequent elements to the left (subtracts one
+   *  from their indices).  Returns the element that was removed from the
+   *  list.
+   * @param index the index of the element to be removed
+   * @return the element previously at the specified position
+   * @throws UnsupportedOperationException if the <tt>remove</tt> operation&#xA; is not supported by this list
+   * @throws IndexOutOfBoundsException if the index is out of range&#xA; (<tt>index &lt; 0 || index &gt;= size()</tt>)
+   */
+  remove(index: number): unknown;
+
+  /**
+   * Returns the index of the first occurrence of the specified element
+   *  in this list, or -1 if this list does not contain the element.
+   *  More formally, returns the lowest index <tt>i</tt> such that
+   *  <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
+   *  or -1 if there is no such index.
+   * @param o element to search for
+   * @return the index of the first occurrence of the specified element in&#xA; this list, or -1 if this list does not contain the element
+   * @throws ClassCastException if the type of the specified element&#xA; is incompatible with this list&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if the specified element is null and this&#xA; list does not permit null elements&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   */
+  indexOf(o: unknown): number;
+
+  /**
+   * Returns the index of the last occurrence of the specified element
+   *  in this list, or -1 if this list does not contain the element.
+   *  More formally, returns the highest index <tt>i</tt> such that
+   *  <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>,
+   *  or -1 if there is no such index.
+   * @param o element to search for
+   * @return the index of the last occurrence of the specified element in&#xA; this list, or -1 if this list does not contain the element
+   * @throws ClassCastException if the type of the specified element&#xA; is incompatible with this list&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   * @throws NullPointerException if the specified element is null and this&#xA; list does not permit null elements&#xA; (<a href="Collection.html#optional-restrictions">optional</a>)
+   */
+  lastIndexOf(o: unknown): number;
+
+  /**
+   * Returns a list iterator over the elements in this list (in proper
+   *  sequence).
+   * @return a list iterator over the elements in this list (in proper&#xA; sequence)
+   */
+  listIterator(): ListIterator;
+
+  /**
+   * Returns a list iterator over the elements in this list (in proper
+   *  sequence), starting at the specified position in the list.
+   *  The specified index indicates the first element that would be
+   *  returned by an initial call to {@link ListIterator#next next}.
+   *  An initial call to {@link ListIterator#previous previous} would
+   *  return the element with the specified index minus one.
+   * @param index index of the first element to be returned from the&#xA; list iterator (by a call to {@link ListIterator#next next})
+   * @return a list iterator over the elements in this list (in proper&#xA; sequence), starting at the specified position in the list
+   * @throws IndexOutOfBoundsException if the index is out of range&#xA; ({@code index < 0 || index > size()})
+   */
+  listIterator(index: number): ListIterator;
+
+  /**
+   * Returns a view of the portion of this list between the specified
+   *  <tt>fromIndex</tt>, inclusive, and <tt>toIndex</tt>, exclusive.  (If
+   *  <tt>fromIndex</tt> and <tt>toIndex</tt> are equal, the returned list is
+   *  empty.)  The returned list is backed by this list, so non-structural
+   *  changes in the returned list are reflected in this list, and vice-versa.
+   *  The returned list supports all of the optional list operations supported
+   *  by this list.<p>
+   *
+   *  This method eliminates the need for explicit range operations (of
+   *  the sort that commonly exist for arrays).  Any operation that expects
+   *  a list can be used as a range operation by passing a subList view
+   *  instead of a whole list.  For example, the following idiom
+   *  removes a range of elements from a list:
+   *  <pre>{@code
+   *       list.subList(from, to).clear();
+   *  }</pre>
+   *  Similar idioms may be constructed for <tt>indexOf</tt> and
+   *  <tt>lastIndexOf</tt>, and all of the algorithms in the
+   *  <tt>Collections</tt> class can be applied to a subList.<p>
+   *
+   *  The semantics of the list returned by this method become undefined if
+   *  the backing list (i.e., this list) is <i>structurally modified</i> in
+   *  any way other than via the returned list.  (Structural modifications are
+   *  those that change the size of this list, or otherwise perturb it in such
+   *  a fashion that iterations in progress may yield incorrect results.)
+   * @param fromIndex low endpoint (inclusive) of the subList
+   * @param toIndex high endpoint (exclusive) of the subList
+   * @return a view of the specified range within this list
+   * @throws IndexOutOfBoundsException for an illegal endpoint index value&#xA; (<tt>fromIndex &lt; 0 || toIndex &gt; size ||&#xA; fromIndex &gt; toIndex</tt>)
+   */
+  subList(fromIndex: number, toIndex: number): List;
+
+  /**
+   * Creates a {@link Spliterator} over the elements in this list.
+   *
+   *  <p>The {@code Spliterator} reports {@link Spliterator#SIZED} and
+   *  {@link Spliterator#ORDERED}.  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 list's {@code Iterator}. The spliterator inherits the&#xA; <em>fail-fast</em> properties of the list's iterator.
+   * @implNote The created {@code Spliterator} additionally reports&#xA; {@link Spliterator#SUBSIZED}.
+   * @return a {@code Spliterator} over the elements in this list
+   * @since 1.8
+   */
+  spliterator(): Spliterator;
+};

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

@@ -0,0 +1,32 @@
+"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() {},
+  removeAll: function removeAll() {},
+  retainAll: function retainAll() {},
+  replaceAll: function replaceAll() {},
+  sort: function sort() {},
+  clear: function clear() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  get: function get() {},
+  set: function set() {},
+  indexOf: function indexOf() {},
+  lastIndexOf: function lastIndexOf() {},
+  listIterator: function listIterator() {},
+  subList: function subList() {},
+  spliterator: function spliterator() {}
+};
+exports["default"] = _default;