@sitevision/api 2023.2.1 → 2023.2.2-beta.2

package/types/java/lang/Cloneable/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A class implements the <code>Cloneable</code> interface to
+ *  indicate to the {@link java.lang.Object#clone()} method that it
+ *  is legal for that method to make a
+ *  field-for-field copy of instances of that class.
+ *  <p>
+ *  Invoking Object's clone method on an instance that does not implement the
+ *  <code>Cloneable</code> interface results in the exception
+ *  <code>CloneNotSupportedException</code> being thrown.
+ *  <p>
+ *  By convention, classes that implement this interface should override
+ *  <tt>Object.clone</tt> (which is protected) with a public method.
+ *  See {@link java.lang.Object#clone()} for details on overriding this
+ *  method.
+ *  <p>
+ *  Note that this interface does <i>not</i> contain the <tt>clone</tt> method.
+ *  Therefore, it is not possible to clone an object merely by virtue of the
+ *  fact that it implements this interface.  Even if the clone method is invoked
+ *  reflectively, there is no guarantee that it will succeed.
+ * @author unascribed
+ * @see java.lang.CloneNotSupportedException
+ * @see java.lang.Object#clone()
+ * @since JDK1.0
+ */
+export type Cloneable = {};

package/types/java/lang/Cloneable/index.js

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

package/types/java/lang/Comparable/index.d.ts

@@ -0,0 +1,103 @@
+/**
+ * This interface imposes a total ordering on the objects of each class that
+ *  implements it.  This ordering is referred to as the class's <i>natural
+ *  ordering</i>, and the class's <tt>compareTo</tt> method is referred to as
+ *  its <i>natural comparison method</i>.<p>
+ *
+ *  Lists (and arrays) of objects that implement this interface can be sorted
+ *  automatically by {@link Collections#sort(List) Collections.sort} (and
+ *  {@link Arrays#sort(Object[]) Arrays.sort}).  Objects that implement this
+ *  interface can be used as keys in a {@linkplain SortedMap sorted map} or as
+ *  elements in a {@linkplain SortedSet sorted set}, without the need to
+ *  specify a {@linkplain Comparator comparator}.<p>
+ *
+ *  The natural ordering for a class <tt>C</tt> is said to be <i>consistent
+ *  with equals</i> if and only if <tt>e1.compareTo(e2) == 0</tt> has
+ *  the same boolean value as <tt>e1.equals(e2)</tt> for every
+ *  <tt>e1</tt> and <tt>e2</tt> of class <tt>C</tt>.  Note that <tt>null</tt>
+ *  is not an instance of any class, and <tt>e.compareTo(null)</tt> should
+ *  throw a <tt>NullPointerException</tt> even though <tt>e.equals(null)</tt>
+ *  returns <tt>false</tt>.<p>
+ *
+ *  It is strongly recommended (though not required) that natural orderings be
+ *  consistent with equals.  This is so because sorted sets (and sorted maps)
+ *  without explicit comparators behave "strangely" when they are used with
+ *  elements (or keys) whose natural ordering is inconsistent with equals.  In
+ *  particular, such a sorted set (or sorted map) violates the general contract
+ *  for set (or map), which is defined in terms of the <tt>equals</tt>
+ *  method.<p>
+ *
+ *  For example, if one adds two keys <tt>a</tt> and <tt>b</tt> such that
+ *  {@code (!a.equals(b) && a.compareTo(b) == 0)} to a sorted
+ *  set that does not use an explicit comparator, the second <tt>add</tt>
+ *  operation returns false (and the size of the sorted set does not increase)
+ *  because <tt>a</tt> and <tt>b</tt> are equivalent from the sorted set's
+ *  perspective.<p>
+ *
+ *  Virtually all Java core classes that implement <tt>Comparable</tt> have natural
+ *  orderings that are consistent with equals.  One exception is
+ *  <tt>java.math.BigDecimal</tt>, whose natural ordering equates
+ *  <tt>BigDecimal</tt> objects with equal values and different precisions
+ *  (such as 4.0 and 4.00).<p>
+ *
+ *  For the mathematically inclined, the <i>relation</i> that defines
+ *  the natural ordering on a given class C is:<pre>
+ *        {(x, y) such that x.compareTo(y) &lt;= 0}.
+ *  </pre> The <i>quotient</i> for this total order is: <pre>
+ *        {(x, y) such that x.compareTo(y) == 0}.
+ *  </pre>
+ *
+ *  It follows immediately from the contract for <tt>compareTo</tt> that the
+ *  quotient is an <i>equivalence relation</i> on <tt>C</tt>, and that the
+ *  natural ordering is a <i>total order</i> on <tt>C</tt>.  When we say that a
+ *  class's natural ordering is <i>consistent with equals</i>, we mean that the
+ *  quotient for the natural ordering is the equivalence relation defined by
+ *  the class's {@link Object#equals(Object) equals(Object)} method:<pre>
+ *      {(x, y) such that x.equals(y)}. </pre><p>
+ *
+ *  This interface is a member of the
+ *  <a href="{@docRoot}/../technotes/guides/collections/index.html">
+ *  Java Collections Framework</a>.
+ * @param <T> the type of objects that this object may be compared to
+ * @author Josh Bloch
+ * @see java.util.Comparator
+ * @since 1.2
+ */
+export type Comparable = {
+  /**
+   * Compares this object with the specified object for order.  Returns a
+   *  negative integer, zero, or a positive integer as this object is less
+   *  than, equal to, or greater than the specified object.
+   *
+   *  <p>The implementor must ensure <tt>sgn(x.compareTo(y)) ==
+   *  -sgn(y.compareTo(x))</tt> for all <tt>x</tt> and <tt>y</tt>.  (This
+   *  implies that <tt>x.compareTo(y)</tt> must throw an exception iff
+   *  <tt>y.compareTo(x)</tt> throws an exception.)
+   *
+   *  <p>The implementor must also ensure that the relation is transitive:
+   *  <tt>(x.compareTo(y)&gt;0 &amp;&amp; y.compareTo(z)&gt;0)</tt> implies
+   *  <tt>x.compareTo(z)&gt;0</tt>.
+   *
+   *  <p>Finally, the implementor must ensure that <tt>x.compareTo(y)==0</tt>
+   *  implies that <tt>sgn(x.compareTo(z)) == sgn(y.compareTo(z))</tt>, for
+   *  all <tt>z</tt>.
+   *
+   *  <p>It is strongly recommended, but <i>not</i> strictly required that
+   *  <tt>(x.compareTo(y)==0) == (x.equals(y))</tt>.  Generally speaking, any
+   *  class that implements the <tt>Comparable</tt> interface and violates
+   *  this condition should clearly indicate this fact.  The recommended
+   *  language is "Note: this class has a natural ordering that is
+   *  inconsistent with equals."
+   *
+   *  <p>In the foregoing description, the notation
+   *  <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
+   *  <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
+   *  <tt>0</tt>, or <tt>1</tt> according to whether the value of
+   *  <i>expression</i> is negative, zero or positive.
+   * @param o the object to be compared.
+   * @return a negative integer, zero, or a positive integer as this object&#xA; is less than, equal to, or greater than the specified object.
+   * @throws NullPointerException if the specified object is null
+   * @throws ClassCastException if the specified object's type prevents it&#xA; from being compared to this object.
+   */
+  compareTo(o: unknown): number;
+};

package/types/java/lang/Comparable/index.js

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

package/types/java/lang/Double/index.d.ts

@@ -0,0 +1,273 @@
+import type { String } from "../String";
+
+import type { Object } from "../Object";
+import type { Number } from "../Number";
+import type { Comparable } from "../Comparable";
+import type { Class } from "../Class";
+
+/**
+ * The {@code Double} class wraps a value of the primitive type
+ *  {@code double} in an object. An object of type
+ *  {@code Double} contains a single field whose type is
+ *  {@code double}.
+ *
+ *  <p>In addition, this class provides several methods for converting a
+ *  {@code double} to a {@code String} and a
+ *  {@code String} to a {@code double}, as well as other
+ *  constants and methods useful when dealing with a
+ *  {@code double}.
+ * @author Lee Boynton
+ * @author Arthur van Hoff
+ * @author Joseph D. Darcy
+ * @since JDK1.0
+ */
+export type Double = Number &
+  Comparable & {
+    /**
+     * Returns {@code true} if this {@code Double} value is
+     *  a Not-a-Number (NaN), {@code false} otherwise.
+     * @return {@code true} if the value represented by this object is&#xA; NaN; {@code false} otherwise.
+     */
+    isNaN(): boolean;
+
+    /**
+     * Returns {@code true} if this {@code Double} value is
+     *  infinitely large in magnitude, {@code false} otherwise.
+     * @return {@code true} if the value represented by this object is&#xA; positive infinity or negative infinity;&#xA; {@code false} otherwise.
+     */
+    isInfinite(): boolean;
+
+    /**
+     * Returns a string representation of this {@code Double} object.
+     *  The primitive {@code double} value represented by this
+     *  object is converted to a string exactly as if by the method
+     *  {@code toString} of one argument.
+     * @return a {@code String} representation of this object.
+     * @see java.lang.Double#toString(double)
+     */
+    toString(): string;
+
+    /**
+     * Returns the value of this {@code Double} as a {@code byte}
+     *  after a narrowing primitive conversion.
+     * @return the {@code double} value represented by this object&#xA; converted to type {@code byte}
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     * @since JDK1.1
+     */
+    byteValue(): unknown;
+
+    /**
+     * Returns the value of this {@code Double} as a {@code short}
+     *  after a narrowing primitive conversion.
+     * @return the {@code double} value represented by this object&#xA; converted to type {@code short}
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     * @since JDK1.1
+     */
+    shortValue(): number;
+
+    /**
+     * Returns the value of this {@code Double} as an {@code int}
+     *  after a narrowing primitive conversion.
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     * @return the {@code double} value represented by this object&#xA; converted to type {@code int}
+     */
+    intValue(): number;
+
+    /**
+     * Returns the value of this {@code Double} as a {@code long}
+     *  after a narrowing primitive conversion.
+     * @return the {@code double} value represented by this object&#xA; converted to type {@code long}
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     */
+    longValue(): number;
+
+    /**
+     * Returns the value of this {@code Double} as a {@code float}
+     *  after a narrowing primitive conversion.
+     * @return the {@code double} value represented by this object&#xA; converted to type {@code float}
+     * @jls 5.1.3 Narrowing Primitive Conversions
+     * @since JDK1.0
+     */
+    floatValue(): number;
+
+    /**
+     * Returns the {@code double} value of this {@code Double} object.
+     * @return the {@code double} value represented by this object
+     */
+    doubleValue(): number;
+
+    /**
+     * Returns a hash code for this {@code Double} object. The
+     *  result is the exclusive OR of the two halves of the
+     *  {@code long} integer bit representation, exactly as
+     *  produced by the method {@link #doubleToLongBits(double)}, of
+     *  the primitive {@code double} value represented by this
+     *  {@code Double} object. That is, the hash code is the value
+     *  of the expression:
+     *
+     *  <blockquote>
+     *   {@code (int)(v^(v>>>32))}
+     *  </blockquote>
+     *
+     *  where {@code v} is defined by:
+     *
+     *  <blockquote>
+     *   {@code long v = Double.doubleToLongBits(this.doubleValue());}
+     *  </blockquote>
+     * @return a {@code hash code} value for this object.
+     */
+    hashCode(): number;
+
+    /**
+     * Compares this object against the specified object.  The result
+     *  is {@code true} if and only if the argument is not
+     *  {@code null} and is a {@code Double} object that
+     *  represents a {@code double} that has the same value as the
+     *  {@code double} represented by this object. For this
+     *  purpose, two {@code double} values are considered to be
+     *  the same if and only if the method {@link
+     *  #doubleToLongBits(double)} returns the identical
+     *  {@code long} value when applied to each.
+     *
+     *  <p>Note that in most cases, for two instances of class
+     *  {@code Double}, {@code d1} and {@code d2}, the
+     *  value of {@code d1.equals(d2)} is {@code true} if and
+     *  only if
+     *
+     *  <blockquote>
+     *   {@code d1.doubleValue() == d2.doubleValue()}
+     *  </blockquote>
+     *
+     *  <p>also has the value {@code true}. However, there are two
+     *  exceptions:
+     *  <ul>
+     *  <li>If {@code d1} and {@code d2} both represent
+     *      {@code Double.NaN}, then the {@code equals} method
+     *      returns {@code true}, even though
+     *      {@code Double.NaN==Double.NaN} has the value
+     *      {@code false}.
+     *  <li>If {@code d1} represents {@code +0.0} while
+     *      {@code d2} represents {@code -0.0}, or vice versa,
+     *      the {@code equal} test has the value {@code false},
+     *      even though {@code +0.0==-0.0} has the value {@code true}.
+     *  </ul>
+     *  This definition allows hash tables to operate properly.
+     * @param obj the object to compare with.
+     * @return {@code true} if the objects are the same;&#xA; {@code false} otherwise.
+     * @see java.lang.Double#doubleToLongBits(double)
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+     * Compares two {@code Double} objects numerically.  There
+     *  are two ways in which comparisons performed by this method
+     *  differ from those performed by the Java language numerical
+     *  comparison operators ({@code <, <=, ==, >=, >})
+     *  when applied to primitive {@code double} values:
+     *  <ul><li>
+     *           {@code Double.NaN} is considered by this method
+     *           to be equal to itself and greater than all other
+     *           {@code double} values (including
+     *           {@code Double.POSITIVE_INFINITY}).
+     *  <li>
+     *           {@code 0.0d} is considered by this method to be greater
+     *           than {@code -0.0d}.
+     *  </ul>
+     *  This ensures that the <i>natural ordering</i> of
+     *  {@code Double} objects imposed by this method is <i>consistent
+     *  with equals</i>.
+     * @param anotherDouble the {@code Double} to be compared.
+     * @return the value {@code 0} if {@code anotherDouble} is&#xA; numerically equal to this {@code Double}; a value&#xA; less than {@code 0} if this {@code Double}&#xA; is numerically less than {@code anotherDouble};&#xA; and a value greater than {@code 0} if this&#xA; {@code Double} is numerically greater than&#xA; {@code anotherDouble}.
+     * @since 1.2
+     */
+    compareTo(anotherDouble: Double | number): number;
+
+    /**
+ * A constant holding the positive infinity of type
+ *  {@code double}. It is equal to the value returned by
+ *  {@code Double.longBitsToDouble(0x7ff0000000000000L)}.
+  
+    */
+    POSITIVE_INFINITY: number;
+
+    /**
+ * A constant holding the negative infinity of type
+ *  {@code double}. It is equal to the value returned by
+ *  {@code Double.longBitsToDouble(0xfff0000000000000L)}.
+  
+    */
+    NEGATIVE_INFINITY: number;
+
+    /**
+ * A constant holding a Not-a-Number (NaN) value of type
+ *  {@code double}. It is equivalent to the value returned by
+ *  {@code Double.longBitsToDouble(0x7ff8000000000000L)}.
+  
+    */
+    NaN: number;
+
+    /**
+ * A constant holding the largest positive finite value of type
+ *  {@code double},
+ *  (2-2<sup>-52</sup>)&middot;2<sup>1023</sup>.  It is equal to
+ *  the hexadecimal floating-point literal
+ *  {@code 0x1.fffffffffffffP+1023} and also equal to
+ *  {@code Double.longBitsToDouble(0x7fefffffffffffffL)}.
+  
+    */
+    MAX_VALUE: number;
+
+    /**
+     * A constant holding the smallest positive normal value of type
+     *  {@code double}, 2<sup>-1022</sup>.  It is equal to the
+     *  hexadecimal floating-point literal {@code 0x1.0p-1022} and also
+     *  equal to {@code Double.longBitsToDouble(0x0010000000000000L)}.
+     * @since 1.6
+     */
+    MIN_NORMAL: number;
+
+    /**
+ * A constant holding the smallest positive nonzero value of type
+ *  {@code double}, 2<sup>-1074</sup>. It is equal to the
+ *  hexadecimal floating-point literal
+ *  {@code 0x0.0000000000001P-1022} and also equal to
+ *  {@code Double.longBitsToDouble(0x1L)}.
+  
+    */
+    MIN_VALUE: number;
+
+    /**
+     * Maximum exponent a finite {@code double} variable may have.
+     *  It is equal to the value returned by
+     *  {@code Math.getExponent(Double.MAX_VALUE)}.
+     * @since 1.6
+     */
+    MAX_EXPONENT: number;
+
+    /**
+     * Minimum exponent a normalized {@code double} variable may
+     *  have.  It is equal to the value returned by
+     *  {@code Math.getExponent(Double.MIN_NORMAL)}.
+     * @since 1.6
+     */
+    MIN_EXPONENT: number;
+
+    /**
+     * The number of bits used to represent a {@code double} value.
+     * @since 1.5
+     */
+    SIZE: number;
+
+    /**
+     * The number of bytes used to represent a {@code double} value.
+     * @since 1.8
+     */
+    BYTES: number;
+
+    /**
+     * The {@code Class} instance representing the primitive type
+     *  {@code double}.
+     * @since JDK1.1
+     */
+    TYPE: Class;
+  };

package/types/java/lang/Double/index.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  isNaN: function isNaN() {},
+  isInfinite: function isInfinite() {},
+  toString: function toString() {},
+  byteValue: function byteValue() {},
+  shortValue: function shortValue() {},
+  intValue: function intValue() {},
+  longValue: function longValue() {},
+  floatValue: function floatValue() {},
+  doubleValue: function doubleValue() {},
+  hashCode: function hashCode() {},
+  equals: function equals() {},
+  compareTo: function compareTo() {}
+};
+exports["default"] = _default;

package/types/java/lang/Enum/index.d.ts

@@ -0,0 +1,118 @@
+import type { String } from "../String";
+
+import type { Object } from "../Object";
+
+import type { Class } from "../Class";
+
+import type { Comparable } from "../Comparable";
+import type { Serializable } from "../../io/Serializable";
+
+/**
+ * This is the common base class of all Java language enumeration types.
+ *
+ *  More information about enums, including descriptions of the
+ *  implicitly declared methods synthesized by the compiler, can be
+ *  found in section 8.9 of
+ *  <cite>The Java&trade; Language Specification</cite>.
+ *
+ *  <p> Note that when using an enumeration type as the type of a set
+ *  or as the type of the keys in a map, specialized and efficient
+ *  {@linkplain java.util.EnumSet set} and {@linkplain
+ *  java.util.EnumMap map} implementations are available.
+ * @param <E> The enum type subclass
+ * @author Josh Bloch
+ * @author Neal Gafter
+ * @see Class#getEnumConstants()
+ * @see java.util.EnumSet
+ * @see java.util.EnumMap
+ * @since 1.5
+ */
+export type Enum = Object &
+  Comparable &
+  Serializable & {
+    /**
+     * Returns the name of this enum constant, exactly as declared in its
+     *  enum declaration.
+     *
+     *  <b>Most programmers should use the {@link #toString} method in
+     *  preference to this one, as the toString method may return
+     *  a more user-friendly name.</b>  This method is designed primarily for
+     *  use in specialized situations where correctness depends on getting the
+     *  exact name, which will not vary from release to release.
+     * @return the name of this enum constant
+     */
+    name(): string;
+
+    /**
+     * Returns the ordinal of this enumeration constant (its position
+     *  in its enum declaration, where the initial constant is assigned
+     *  an ordinal of zero).
+     *
+     *  Most programmers will have no use for this method.  It is
+     *  designed for use by sophisticated enum-based data structures, such
+     *  as {@link java.util.EnumSet} and {@link java.util.EnumMap}.
+     * @return the ordinal of this enumeration constant
+     */
+    ordinal(): number;
+
+    /**
+     * Returns the name of this enum constant, as contained in the
+     *  declaration.  This method may be overridden, though it typically
+     *  isn't necessary or desirable.  An enum type should override this
+     *  method when a more "programmer-friendly" string form exists.
+     * @return the name of this enum constant
+     */
+    toString(): string;
+
+    /**
+     * Returns true if the specified object is equal to this
+     *  enum constant.
+     * @param other the object to be compared for equality with this object.
+     * @return true if the specified object is equal to this&#xA; enum constant.
+     */
+    equals(other: unknown): boolean;
+
+    /**
+     * Returns a hash code for this enum constant.
+     * @return a hash code for this enum constant.
+     */
+    hashCode(): number;
+
+    /**
+     * Throws CloneNotSupportedException.  This guarantees that enums
+     *  are never cloned, which is necessary to preserve their "singleton"
+     *  status.
+     * @return (never returns)
+     */
+    clone(): unknown;
+
+    /**
+ * Compares this enum with the specified object for order.  Returns a
+ *  negative integer, zero, or a positive integer as this object is less
+ *  than, equal to, or greater than the specified object.
+ * 
+ *  Enum constants are only comparable to other enum constants of the
+ *  same enum type.  The natural order implemented by this
+ *  method is the order in which the constants are declared.
+  
+    */
+    compareTo(o: unknown): number;
+
+    /**
+     * Returns the Class object corresponding to this enum constant's
+     *  enum type.  Two enum constants e1 and  e2 are of the
+     *  same enum type if and only if
+     *    e1.getDeclaringClass() == e2.getDeclaringClass().
+     *  (The value returned by this method may differ from the one returned
+     *  by the {@link Object#getClass} method for enum constants with
+     *  constant-specific class bodies.)
+     * @return the Class object corresponding to this enum constant's&#xA; enum type
+     */
+    getDeclaringClass(): Class;
+
+    /**
+ * enum classes cannot have finalize methods.
+  
+    */
+    finalize(): void;
+  };

package/types/java/lang/Enum/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _default = {
+  name: function name() {},
+  ordinal: function ordinal() {},
+  toString: function toString() {},
+  equals: function equals() {},
+  hashCode: function hashCode() {},
+  clone: function clone() {},
+  compareTo: function compareTo() {},
+  getDeclaringClass: function getDeclaringClass() {},
+  finalize: function finalize() {}
+};
+exports["default"] = _default;

package/types/java/lang/Exception/index.d.ts

@@ -0,0 +1,19 @@
+import type { Throwable } from "../Throwable";
+
+/**
+ * The class {@code Exception} and its subclasses are a form of
+ *  {@code Throwable} that indicates conditions that a reasonable
+ *  application might want to catch.
+ *
+ *  <p>The class {@code Exception} and any subclasses that are not also
+ *  subclasses of {@link RuntimeException} are <em>checked
+ *  exceptions</em>.  Checked exceptions need to be declared in a
+ *  method or constructor's {@code throws} clause if they can be thrown
+ *  by the execution of the method or constructor and propagate outside
+ *  the method or constructor boundary.
+ * @author Frank Yellin
+ * @see java.lang.Error
+ * @jls 11.2 Compile-Time Checking of Exceptions
+ * @since JDK1.0
+ */
+export type Exception = Throwable & {};

package/types/java/lang/Exception/index.js

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