@sitevision/api 2023.2.1 → 2023.2.2-beta.1

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

@@ -0,0 +1,121 @@
+import type { String } from "../../lang/String";
+import type { Object } from "../../lang/Object";
+import type { DoubleConsumer } from "../function/DoubleConsumer";
+
+/**
+ * A state object for collecting statistics such as count, min, max, sum, and
+ *  average.
+ *
+ *  <p>This class is designed to work with (though does not require)
+ *  {@linkplain java.util.stream streams}. For example, you can compute
+ *  summary statistics on a stream of doubles with:
+ *  <pre> {@code
+ *  DoubleSummaryStatistics stats = doubleStream.collect(DoubleSummaryStatistics::new,
+ *                                                       DoubleSummaryStatistics::accept,
+ *                                                       DoubleSummaryStatistics::combine);
+ *  }</pre>
+ *
+ *  <p>{@code DoubleSummaryStatistics} can be used as a
+ *  {@linkplain java.util.stream.Stream#collect(Collector) reduction}
+ *  target for a {@linkplain java.util.stream.Stream stream}. For example:
+ *
+ *  <pre> {@code
+ *  DoubleSummaryStatistics stats = people.stream()
+ *      .collect(Collectors.summarizingDouble(Person::getWeight));
+ * }</pre>
+ *
+ *  This computes, in a single pass, the count of people, as well as the minimum,
+ *  maximum, sum, and average of their weights.
+ * @implNote This implementation is not thread safe. However, it is safe to use&#xA; {@link java.util.stream.Collectors#summarizingDouble(java.util.function.ToDoubleFunction)&#xA; Collectors.toDoubleStatistics()} on a parallel stream, because the parallel&#xA; implementation of {@link java.util.stream.Stream#collect Stream.collect()}&#xA; provides the necessary partitioning, isolation, and merging of results for&#xA; safe and efficient parallel execution.
+ * @since 1.8
+ */
+export type DoubleSummaryStatistics = Object &
+  DoubleConsumer & {
+    /**
+     * Records another value into the summary information.
+     * @param value the input value
+     */
+    accept(value: number): void;
+
+    /**
+     * Combines the state of another {@code DoubleSummaryStatistics} into this
+     *  one.
+     * @param other another {@code DoubleSummaryStatistics}
+     * @throws NullPointerException if {@code other} is null
+     */
+    combine(other: DoubleSummaryStatistics): void;
+
+    /**
+     * Return the count of values recorded.
+     * @return the count of values
+     */
+    getCount(): number;
+
+    /**
+     * Returns the sum of values recorded, or zero if no values have been
+     *  recorded.
+     *
+     *  If any recorded value is a NaN or the sum is at any point a NaN
+     *  then the sum will be NaN.
+     *
+     *  <p> The value of a floating-point sum is a function both of the
+     *  input values as well as the order of addition operations. The
+     *  order of addition operations of this method is intentionally
+     *  not defined to allow for implementation flexibility to improve
+     *  the speed and accuracy of the computed result.
+     *
+     *  In particular, this method may be implemented using compensated
+     *  summation or other technique to reduce the error bound in the
+     *  numerical sum compared to a simple summation of {@code double}
+     *  values.
+     * @apiNote Values sorted by increasing absolute magnitude tend to yield&#xA; more accurate results.
+     * @return the sum of values, or zero if none
+     */
+    getSum(): number;
+
+    /**
+     * Returns the minimum recorded value, {@code Double.NaN} if any recorded
+     *  value was NaN or {@code Double.POSITIVE_INFINITY} if no values were
+     *  recorded. Unlike the numerical comparison operators, this method
+     *  considers negative zero to be strictly smaller than positive zero.
+     * @return the minimum recorded value, {@code Double.NaN} if any recorded&#xA; value was NaN or {@code Double.POSITIVE_INFINITY} if no values were&#xA; recorded
+     */
+    getMin(): number;
+
+    /**
+     * Returns the maximum recorded value, {@code Double.NaN} if any recorded
+     *  value was NaN or {@code Double.NEGATIVE_INFINITY} if no values were
+     *  recorded. Unlike the numerical comparison operators, this method
+     *  considers negative zero to be strictly smaller than positive zero.
+     * @return the maximum recorded value, {@code Double.NaN} if any recorded&#xA; value was NaN or {@code Double.NEGATIVE_INFINITY} if no values were&#xA; recorded
+     */
+    getMax(): number;
+
+    /**
+     * Returns the arithmetic mean of values recorded, or zero if no
+     *  values have been recorded.
+     *
+     *  If any recorded value is a NaN or the sum is at any point a NaN
+     *  then the average will be code NaN.
+     *
+     *  <p>The average returned can vary depending upon the order in
+     *  which values are recorded.
+     *
+     *  This method may be implemented using compensated summation or
+     *  other technique to reduce the error bound in the {@link #getSum
+     *  numerical sum} used to compute the average.
+     * @apiNote Values sorted by increasing absolute magnitude tend to yield&#xA; more accurate results.
+     * @return the arithmetic mean of values, or zero if none
+     */
+    getAverage(): 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.
+  
+    */
+    toString(): string;
+  };

package/types/java/util/DoubleSummaryStatistics/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/Enumeration/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * An object that implements the Enumeration interface generates a
+ *  series of elements, one at a time. Successive calls to the
+ *  <code>nextElement</code> method return successive elements of the
+ *  series.
+ *  <p>
+ *  For example, to print all elements of a <tt>Vector&lt;E&gt;</tt> <i>v</i>:
+ *  <pre>
+ *    for (Enumeration&lt;E&gt; e = v.elements(); e.hasMoreElements();)
+ *        System.out.println(e.nextElement());</pre>
+ *  <p>
+ *  Methods are provided to enumerate through the elements of a
+ *  vector, the keys of a hashtable, and the values in a hashtable.
+ *  Enumerations are also used to specify the input streams to a
+ *  <code>SequenceInputStream</code>.
+ *  <p>
+ *  NOTE: The functionality of this interface is duplicated by the Iterator
+ *  interface.  In addition, Iterator adds an optional remove operation, and
+ *  has shorter method names.  New implementations should consider using
+ *  Iterator in preference to Enumeration.
+ * @see java.util.Iterator
+ * @see java.io.SequenceInputStream
+ * @see java.util.Enumeration#nextElement()
+ * @see java.util.Hashtable
+ * @see java.util.Hashtable#elements()
+ * @see java.util.Hashtable#keys()
+ * @see java.util.Vector
+ * @see java.util.Vector#elements()
+ * @author Lee Boynton
+ * @since JDK1.0
+ */
+export type Enumeration = {
+  /**
+   * Tests if this enumeration contains more elements.
+   * @return <code>true</code> if and only if this enumeration object&#xA; contains at least one more element to provide;&#xA; <code>false</code> otherwise.
+   */
+  hasMoreElements(): boolean;
+
+  /**
+   * Returns the next element of this enumeration if this enumeration
+   *  object has at least one more element to provide.
+   * @return the next element of this enumeration.
+   * @throws NoSuchElementException if no more elements exist.
+   */
+  nextElement(): unknown;
+};

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

@@ -0,0 +1,11 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  hasMoreElements: function hasMoreElements() {},
+  nextElement: function nextElement() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,356 @@
+import type { Enumeration } from "../Enumeration";
+import type { Object } from "../../lang/Object";
+
+import type { Map } from "../Map";
+import type { String } from "../../lang/String";
+import type { Set } from "../Set";
+import type { Collection } from "../Collection";
+import type { BiConsumer } from "../function/BiConsumer";
+import type { BiFunction } from "../function/BiFunction";
+import type { Function } from "../function/Function";
+import type { Dictionary } from "../Dictionary";
+import type { Cloneable } from "../../lang/Cloneable";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * This class implements a hash table, which maps keys to values. Any
+ *  non-<code>null</code> object can be used as a key or as a value. <p>
+ *
+ *  To successfully store and retrieve objects from a hashtable, the
+ *  objects used as keys must implement the <code>hashCode</code>
+ *  method and the <code>equals</code> method. <p>
+ *
+ *  An instance of <code>Hashtable</code> has two parameters that affect its
+ *  performance: <i>initial capacity</i> and <i>load factor</i>.  The
+ *  <i>capacity</i> is the number of <i>buckets</i> in the hash table, and the
+ *  <i>initial capacity</i> is simply the capacity at the time the hash table
+ *  is created.  Note that the hash table is <i>open</i>: in the case of a "hash
+ *  collision", a single bucket stores multiple entries, which must be searched
+ *  sequentially.  The <i>load factor</i> is a measure of how full the hash
+ *  table is allowed to get before its capacity is automatically increased.
+ *  The initial capacity and load factor parameters are merely hints to
+ *  the implementation.  The exact details as to when and whether the rehash
+ *  method is invoked are implementation-dependent.<p>
+ *
+ *  Generally, the default load factor (.75) offers a good tradeoff between
+ *  time and space costs.  Higher values decrease the space overhead but
+ *  increase the time cost to look up an entry (which is reflected in most
+ *  <tt>Hashtable</tt> operations, including <tt>get</tt> and <tt>put</tt>).<p>
+ *
+ *  The initial capacity controls a tradeoff between wasted space and the
+ *  need for <code>rehash</code> operations, which are time-consuming.
+ *  No <code>rehash</code> operations will <i>ever</i> occur if the initial
+ *  capacity is greater than the maximum number of entries the
+ *  <tt>Hashtable</tt> will contain divided by its load factor.  However,
+ *  setting the initial capacity too high can waste space.<p>
+ *
+ *  If many entries are to be made into a <code>Hashtable</code>,
+ *  creating it with a sufficiently large capacity may allow the
+ *  entries to be inserted more efficiently than letting it perform
+ *  automatic rehashing as needed to grow the table. <p>
+ *
+ *  This example creates a hashtable of numbers. It uses the names of
+ *  the numbers as keys:
+ *  <pre>   {@code
+ *    Hashtable<String, Integer> numbers
+ *      = new Hashtable<String, Integer>();
+ *    numbers.put("one", 1);
+ *    numbers.put("two", 2);
+ *    numbers.put("three", 3);}</pre>
+ *
+ *  <p>To retrieve a number, use the following code:
+ *  <pre>   {@code
+ *    Integer n = numbers.get("two");
+ *    if (n != null) {
+ *      System.out.println("two = " + n);
+ *    }}</pre>
+ *
+ *  <p>The iterators returned by the <tt>iterator</tt> method of the collections
+ *  returned by all of this class's "collection view methods" are
+ *  <em>fail-fast</em>: if the Hashtable is structurally modified at any time
+ *  after the iterator is created, in any way except through the iterator's own
+ *  <tt>remove</tt> method, the iterator will throw a {@link
+ *  ConcurrentModificationException}.  Thus, in the face of concurrent
+ *  modification, the iterator fails quickly and cleanly, rather than risking
+ *  arbitrary, non-deterministic behavior at an undetermined time in the future.
+ *  The Enumerations returned by Hashtable's keys and elements methods are
+ *  <em>not</em> fail-fast.
+ *
+ *  <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
+ *  as it is, generally speaking, impossible to make any hard guarantees in the
+ *  presence of unsynchronized concurrent modification.  Fail-fast iterators
+ *  throw <tt>ConcurrentModificationException</tt> on a best-effort basis.
+ *  Therefore, it would be wrong to write a program that depended on this
+ *  exception for its correctness: <i>the fail-fast behavior of iterators
+ *  should be used only to detect bugs.</i>
+ *
+ *  <p>As of the Java 2 platform v1.2, this class was retrofitted to
+ *  implement the {@link Map} interface, making it a member of the
+ *  <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ *
+ *  Java Collections Framework</a>.  Unlike the new collection
+ *  implementations, {@code Hashtable} is synchronized.  If a
+ *  thread-safe implementation is not needed, it is recommended to use
+ *  {@link HashMap} in place of {@code Hashtable}.  If a thread-safe
+ *  highly-concurrent implementation is desired, then it is recommended
+ *  to use {@link java.util.concurrent.ConcurrentHashMap} in place of
+ *  {@code Hashtable}.
+ * @author Arthur van Hoff
+ * @author Josh Bloch
+ * @author Neal Gafter
+ * @see Object#equals(java.lang.Object)
+ * @see Object#hashCode()
+ * @see Hashtable#rehash()
+ * @see Collection
+ * @see Map
+ * @see HashMap
+ * @see TreeMap
+ * @since JDK1.0
+ */
+export type Hashtable = Dictionary &
+  Map &
+  Cloneable &
+  Serializable & {
+    /**
+     * Returns the number of keys in this hashtable.
+     * @return the number of keys in this hashtable.
+     */
+    size(): number;
+
+    /**
+     * Tests if this hashtable maps no keys to values.
+     * @return <code>true</code> if this hashtable maps no keys to values;&#xA; <code>false</code> otherwise.
+     */
+    isEmpty(): boolean;
+
+    /**
+     * Returns an enumeration of the keys in this hashtable.
+     * @return an enumeration of the keys in this hashtable.
+     * @see Enumeration
+     * @see #elements()
+     * @see #keySet()
+     * @see Map
+     */
+    keys(): Enumeration;
+
+    /**
+     * Returns an enumeration of the values in this hashtable.
+     *  Use the Enumeration methods on the returned object to fetch the elements
+     *  sequentially.
+     * @return an enumeration of the values in this hashtable.
+     * @see java.util.Enumeration
+     * @see #keys()
+     * @see #values()
+     * @see Map
+     */
+    elements(): Enumeration;
+
+    /**
+     * Tests if some key maps into the specified value in this hashtable.
+     *  This operation is more expensive than the {@link #containsKey
+     *  containsKey} method.
+     *
+     *  <p>Note that this method is identical in functionality to
+     *  {@link #containsValue containsValue}, (which is part of the
+     *  {@link Map} interface in the collections framework).
+     * @param value a value to search for
+     * @return <code>true</code> if and only if some key maps to the&#xA; <code>value</code> argument in this hashtable as&#xA; determined by the <tt>equals</tt> method;&#xA; <code>false</code> otherwise.
+     * @throws NullPointerException if the value is <code>null</code>
+     */
+    contains(value: unknown): boolean;
+
+    /**
+     * Returns true if this hashtable maps one or more keys to this value.
+     *
+     *  <p>Note that this method is identical in functionality to {@link
+     *  #contains contains} (which predates the {@link Map} interface).
+     * @param value value whose presence in this hashtable is to be tested
+     * @return <tt>true</tt> if this map maps one or more keys to the&#xA; specified value
+     * @throws NullPointerException if the value is <code>null</code>
+     * @since 1.2
+     */
+    containsValue(value: unknown): boolean;
+
+    /**
+     * Tests if the specified object is a key in this hashtable.
+     * @param key possible key
+     * @return <code>true</code> if and only if the specified object&#xA; is a key in this hashtable, as determined by the&#xA; <tt>equals</tt> method; <code>false</code> otherwise.
+     * @throws NullPointerException if the key is <code>null</code>
+     * @see #contains(Object)
+     */
+    containsKey(key: unknown): boolean;
+
+    /**
+     * Returns the value to which the specified key is mapped,
+     *  or {@code null} if this map contains no mapping for the key.
+     *
+     *  <p>More formally, if this map contains a mapping from a key
+     *  {@code k} to a value {@code v} such that {@code (key.equals(k))},
+     *  then this method returns {@code v}; otherwise it returns
+     *  {@code null}.  (There can be at most one such mapping.)
+     * @param key the key whose associated value is to be returned
+     * @return the value to which the specified key is mapped, or&#xA; {@code null} if this map contains no mapping for the key
+     * @throws NullPointerException if the specified key is null
+     * @see #put(Object, Object)
+     */
+    get(key: unknown): unknown;
+
+    /**
+ * Increases the capacity of and internally reorganizes this
+ *  hashtable, in order to accommodate and access its entries more
+ *  efficiently.  This method is called automatically when the
+ *  number of keys in the hashtable exceeds this hashtable's capacity
+ *  and load factor.
+  
+    */
+    rehash(): void;
+
+    /**
+     * Maps the specified <code>key</code> to the specified
+     *  <code>value</code> in this hashtable. Neither the key nor the
+     *  value can be <code>null</code>. <p>
+     *
+     *  The value can be retrieved by calling the <code>get</code> method
+     *  with a key that is equal to the original key.
+     * @param key the hashtable key
+     * @param value the value
+     * @return the previous value of the specified key in this hashtable,&#xA; or <code>null</code> if it did not have one
+     * @throws NullPointerException if the key or value is&#xA; <code>null</code>
+     * @see Object#equals(Object)
+     * @see #get(Object)
+     */
+    put(key: unknown, value: unknown): unknown;
+
+    /**
+     * Removes the key (and its corresponding value) from this
+     *  hashtable. This method does nothing if the key is not in the hashtable.
+     * @param key the key that needs to be removed
+     * @return the value to which the key had been mapped in this hashtable,&#xA; or <code>null</code> if the key did not have a mapping
+     * @throws NullPointerException if the key is <code>null</code>
+     */
+    remove(key: unknown): unknown;
+
+    /**
+     * Copies all of the mappings from the specified map to this hashtable.
+     *  These mappings will replace any mappings that this hashtable had for any
+     *  of the keys currently in the specified map.
+     * @param t mappings to be stored in this map
+     * @throws NullPointerException if the specified map is null
+     * @since 1.2
+     */
+    putAll(t: Map | {}): void;
+
+    /**
+ * Clears this hashtable so that it contains no keys.
+  
+    */
+    clear(): void;
+
+    /**
+     * Creates a shallow copy of this hashtable. All the structure of the
+     *  hashtable itself is copied, but the keys and values are not cloned.
+     *  This is a relatively expensive operation.
+     * @return a clone of the hashtable
+     */
+    clone(): unknown;
+
+    /**
+     * Returns a string representation of this <tt>Hashtable</tt> object
+     *  in the form of a set of entries, enclosed in braces and separated
+     *  by the ASCII characters "<tt>,&nbsp;</tt>" (comma and space). Each
+     *  entry is rendered as the key, an equals sign <tt>=</tt>, and the
+     *  associated element, where the <tt>toString</tt> method is used to
+     *  convert the key and element to strings.
+     * @return a string representation of this hashtable
+     */
+    toString(): string;
+
+    /**
+     * Returns a {@link Set} view of the keys contained in this map.
+     *  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 <tt>remove</tt> operation), the results of
+     *  the iteration are undefined.  The set supports element removal,
+     *  which removes the corresponding mapping from the map, via the
+     *  <tt>Iterator.remove</tt>, <tt>Set.remove</tt>,
+     *  <tt>removeAll</tt>, <tt>retainAll</tt>, and <tt>clear</tt>
+     *  operations.  It does not support the <tt>add</tt> or <tt>addAll</tt>
+     *  operations.
+     * @since 1.2
+     */
+    keySet(): Set;
+
+    /**
+     * Returns a {@link Set} view of the mappings contained in this map.
+     *  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 <tt>remove</tt> operation, or through the
+     *  <tt>setValue</tt> 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 <tt>Iterator.remove</tt>,
+     *  <tt>Set.remove</tt>, <tt>removeAll</tt>, <tt>retainAll</tt> and
+     *  <tt>clear</tt> operations.  It does not support the
+     *  <tt>add</tt> or <tt>addAll</tt> operations.
+     * @since 1.2
+     */
+    entrySet(): Set;
+
+    /**
+     * Returns a {@link Collection} view of the values contained in this map.
+     *  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 <tt>remove</tt> operation),
+     *  the results of the iteration are undefined.  The collection
+     *  supports element removal, which removes the corresponding
+     *  mapping from the map, via the <tt>Iterator.remove</tt>,
+     *  <tt>Collection.remove</tt>, <tt>removeAll</tt>,
+     *  <tt>retainAll</tt> and <tt>clear</tt> operations.  It does not
+     *  support the <tt>add</tt> or <tt>addAll</tt> operations.
+     * @since 1.2
+     */
+    values(): Collection;
+
+    /**
+     * Compares the specified Object with this Map for equality,
+     *  as per the definition in the Map interface.
+     * @param o object to be compared for equality with this hashtable
+     * @return true if the specified Object is equal to this Map
+     * @see Map#equals(Object)
+     * @since 1.2
+     */
+    equals(o: unknown): boolean;
+
+    /**
+     * Returns the hash code value for this Map as per the definition in the
+     *  Map interface.
+     * @see Map#hashCode()
+     * @since 1.2
+     */
+    hashCode(): number;
+
+    getOrDefault(key: unknown, defaultValue: unknown): unknown;
+
+    forEach(action: BiConsumer): void;
+
+    replaceAll(afunction: BiFunction): void;
+
+    putIfAbsent(key: unknown, value: unknown): unknown;
+
+    remove(key: unknown, value: unknown): boolean;
+
+    replace(key: unknown, oldValue: unknown, newValue: unknown): boolean;
+
+    replace(key: unknown, value: unknown): unknown;
+
+    computeIfAbsent(key: unknown, mappingFunction: Function): unknown;
+
+    computeIfPresent(key: unknown, remappingFunction: BiFunction): unknown;
+
+    compute(key: unknown, remappingFunction: BiFunction): unknown;
+
+    merge(key: unknown, value: unknown, remappingFunction: BiFunction): unknown;
+  };

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

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  size: function size() {},
+  isEmpty: function isEmpty() {},
+  keys: function keys() {},
+  elements: function elements() {},
+  contains: function contains() {},
+  containsValue: function containsValue() {},
+  containsKey: function containsKey() {},
+  get: function get() {},
+  rehash: function rehash() {},
+  put: function put() {},
+  remove: function remove() {},
+  putAll: function putAll() {},
+  clear: function clear() {},
+  clone: function clone() {},
+  toString: function toString() {},
+  keySet: function keySet() {},
+  entrySet: function entrySet() {},
+  values: function values() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  getOrDefault: function getOrDefault() {},
+  forEach: function forEach() {},
+  replaceAll: function replaceAll() {},
+  putIfAbsent: function putIfAbsent() {},
+  replace: function replace() {},
+  computeIfAbsent: function computeIfAbsent() {},
+  computeIfPresent: function computeIfPresent() {},
+  compute: function compute() {},
+  merge: function merge() {}
+};
+exports["default"] = _default;

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

@@ -0,0 +1,82 @@
+import type { String } from "../../lang/String";
+import type { Object } from "../../lang/Object";
+import type { IntConsumer } from "../function/IntConsumer";
+
+/**
+ * A state object for collecting statistics such as count, min, max, sum, and
+ *  average.
+ *
+ *  <p>This class is designed to work with (though does not require)
+ *  {@linkplain java.util.stream streams}. For example, you can compute
+ *  summary statistics on a stream of ints with:
+ *  <pre> {@code
+ *  IntSummaryStatistics stats = intStream.collect(IntSummaryStatistics::new,
+ *                                                 IntSummaryStatistics::accept,
+ *                                                 IntSummaryStatistics::combine);
+ *  }</pre>
+ *
+ *  <p>{@code IntSummaryStatistics} can be used as a
+ *  {@linkplain java.util.stream.Stream#collect(Collector) reduction}
+ *  target for a {@linkplain java.util.stream.Stream stream}. For example:
+ *
+ *  <pre> {@code
+ *  IntSummaryStatistics stats = people.stream()
+ *                                     .collect(Collectors.summarizingInt(Person::getDependents));
+ * }</pre>
+ *
+ *  This computes, in a single pass, the count of people, as well as the minimum,
+ *  maximum, sum, and average of their number of dependents.
+ * @implNote This implementation is not thread safe. However, it is safe to use&#xA; {@link java.util.stream.Collectors#summarizingInt(java.util.function.ToIntFunction)&#xA; Collectors.toIntStatistics()} on a parallel stream, because the parallel&#xA; implementation of {@link java.util.stream.Stream#collect Stream.collect()}&#xA; provides the necessary partitioning, isolation, and merging of results for&#xA; safe and efficient parallel execution.&#xA;&#xA; <p>This implementation does not check for overflow of the sum.
+ * @since 1.8
+ */
+export type IntSummaryStatistics = Object &
+  IntConsumer & {
+    /**
+     * Records a new value into the summary information
+     * @param value the input value
+     */
+    accept(value: number): void;
+
+    /**
+     * Combines the state of another {@code IntSummaryStatistics} into this one.
+     * @param other another {@code IntSummaryStatistics}
+     * @throws NullPointerException if {@code other} is null
+     */
+    combine(other: IntSummaryStatistics): void;
+
+    /**
+     * Returns the count of values recorded.
+     * @return the count of values
+     */
+    getCount(): number;
+
+    /**
+     * Returns the sum of values recorded, or zero if no values have been
+     *  recorded.
+     * @return the sum of values, or zero if none
+     */
+    getSum(): number;
+
+    /**
+     * Returns the minimum value recorded, or {@code Integer.MAX_VALUE} if no
+     *  values have been recorded.
+     * @return the minimum value, or {@code Integer.MAX_VALUE} if none
+     */
+    getMin(): number;
+
+    /**
+     * Returns the maximum value recorded, or {@code Integer.MIN_VALUE} if no
+     *  values have been recorded.
+     * @return the maximum value, or {@code Integer.MIN_VALUE} if none
+     */
+    getMax(): number;
+
+    /**
+     * Returns the arithmetic mean of values recorded, or zero if no values have been
+     *  recorded.
+     * @return the arithmetic mean of values, or zero if none
+     */
+    getAverage(): number;
+
+    toString(): string;
+  };