@sitevision/api 2023.2.1 → 2023.2.2-beta.1

package/types/java/io/Serializable/index.d.ts

@@ -0,0 +1,141 @@
+/**
+ * Serializability of a class is enabled by the class implementing the
+ *  java.io.Serializable interface. Classes that do not implement this
+ *  interface will not have any of their state serialized or
+ *  deserialized.  All subtypes of a serializable class are themselves
+ *  serializable.  The serialization interface has no methods or fields
+ *  and serves only to identify the semantics of being serializable. <p>
+ *
+ *  To allow subtypes of non-serializable classes to be serialized, the
+ *  subtype may assume responsibility for saving and restoring the
+ *  state of the supertype's public, protected, and (if accessible)
+ *  package fields.  The subtype may assume this responsibility only if
+ *  the class it extends has an accessible no-arg constructor to
+ *  initialize the class's state.  It is an error to declare a class
+ *  Serializable if this is not the case.  The error will be detected at
+ *  runtime. <p>
+ *
+ *  During deserialization, the fields of non-serializable classes will
+ *  be initialized using the public or protected no-arg constructor of
+ *  the class.  A no-arg constructor must be accessible to the subclass
+ *  that is serializable.  The fields of serializable subclasses will
+ *  be restored from the stream. <p>
+ *
+ *  When traversing a graph, an object may be encountered that does not
+ *  support the Serializable interface. In this case the
+ *  NotSerializableException will be thrown and will identify the class
+ *  of the non-serializable object. <p>
+ *
+ *  Classes that require special handling during the serialization and
+ *  deserialization process must implement special methods with these exact
+ *  signatures:
+ *
+ *  <PRE>
+ *  private void writeObject(java.io.ObjectOutputStream out)
+ *      throws IOException
+ *  private void readObject(java.io.ObjectInputStream in)
+ *      throws IOException, ClassNotFoundException;
+ *  private void readObjectNoData()
+ *      throws ObjectStreamException;
+ *  </PRE>
+ *
+ *  <p>The writeObject method is responsible for writing the state of the
+ *  object for its particular class so that the corresponding
+ *  readObject method can restore it.  The default mechanism for saving
+ *  the Object's fields can be invoked by calling
+ *  out.defaultWriteObject. The method does not need to concern
+ *  itself with the state belonging to its superclasses or subclasses.
+ *  State is saved by writing the individual fields to the
+ *  ObjectOutputStream using the writeObject method or by using the
+ *  methods for primitive data types supported by DataOutput.
+ *
+ *  <p>The readObject method is responsible for reading from the stream and
+ *  restoring the classes fields. It may call in.defaultReadObject to invoke
+ *  the default mechanism for restoring the object's non-static and
+ *  non-transient fields.  The defaultReadObject method uses information in
+ *  the stream to assign the fields of the object saved in the stream with the
+ *  correspondingly named fields in the current object.  This handles the case
+ *  when the class has evolved to add new fields. The method does not need to
+ *  concern itself with the state belonging to its superclasses or subclasses.
+ *  State is saved by writing the individual fields to the
+ *  ObjectOutputStream using the writeObject method or by using the
+ *  methods for primitive data types supported by DataOutput.
+ *
+ *  <p>The readObjectNoData method is responsible for initializing the state of
+ *  the object for its particular class in the event that the serialization
+ *  stream does not list the given class as a superclass of the object being
+ *  deserialized.  This may occur in cases where the receiving party uses a
+ *  different version of the deserialized instance's class than the sending
+ *  party, and the receiver's version extends classes that are not extended by
+ *  the sender's version.  This may also occur if the serialization stream has
+ *  been tampered; hence, readObjectNoData is useful for initializing
+ *  deserialized objects properly despite a "hostile" or incomplete source
+ *  stream.
+ *
+ *  <p>Serializable classes that need to designate an alternative object to be
+ *  used when writing an object to the stream should implement this
+ *  special method with the exact signature:
+ *
+ *  <PRE>
+ *  ANY-ACCESS-MODIFIER Object writeReplace() throws ObjectStreamException;
+ *  </PRE><p>
+ *
+ *  This writeReplace method is invoked by serialization if the method
+ *  exists and it would be accessible from a method defined within the
+ *  class of the object being serialized. Thus, the method can have private,
+ *  protected and package-private access. Subclass access to this method
+ *  follows java accessibility rules. <p>
+ *
+ *  Classes that need to designate a replacement when an instance of it
+ *  is read from the stream should implement this special method with the
+ *  exact signature.
+ *
+ *  <PRE>
+ *  ANY-ACCESS-MODIFIER Object readResolve() throws ObjectStreamException;
+ *  </PRE><p>
+ *
+ *  This readResolve method follows the same invocation rules and
+ *  accessibility rules as writeReplace.<p>
+ *
+ *  The serialization runtime associates with each serializable class a version
+ *  number, called a serialVersionUID, which is used during deserialization to
+ *  verify that the sender and receiver of a serialized object have loaded
+ *  classes for that object that are compatible with respect to serialization.
+ *  If the receiver has loaded a class for the object that has a different
+ *  serialVersionUID than that of the corresponding sender's class, then
+ *  deserialization will result in an {@link InvalidClassException}.  A
+ *  serializable class can declare its own serialVersionUID explicitly by
+ *  declaring a field named <code>"serialVersionUID"</code> that must be static,
+ *  final, and of type <code>long</code>:
+ *
+ *  <PRE>
+ *  ANY-ACCESS-MODIFIER static final long serialVersionUID = 42L;
+ *  </PRE>
+ *
+ *  If a serializable class does not explicitly declare a serialVersionUID, then
+ *  the serialization runtime will calculate a default serialVersionUID value
+ *  for that class based on various aspects of the class, as described in the
+ *  Java(TM) Object Serialization Specification.  However, it is <em>strongly
+ *  recommended</em> that all serializable classes explicitly declare
+ *  serialVersionUID values, since the default serialVersionUID computation is
+ *  highly sensitive to class details that may vary depending on compiler
+ *  implementations, and can thus result in unexpected
+ *  <code>InvalidClassException</code>s during deserialization.  Therefore, to
+ *  guarantee a consistent serialVersionUID value across different java compiler
+ *  implementations, a serializable class must declare an explicit
+ *  serialVersionUID value.  It is also strongly advised that explicit
+ *  serialVersionUID declarations use the <code>private</code> modifier where
+ *  possible, since such declarations apply only to the immediately declaring
+ *  class--serialVersionUID fields are not useful as inherited members. Array
+ *  classes cannot declare an explicit serialVersionUID, so they always have
+ *  the default computed value, but the requirement for matching
+ *  serialVersionUID values is waived for array classes.
+ * @author unascribed
+ * @see java.io.ObjectOutputStream
+ * @see java.io.ObjectInputStream
+ * @see java.io.ObjectOutput
+ * @see java.io.ObjectInput
+ * @see java.io.Externalizable
+ * @since JDK1.1
+ */
+export type Serializable = {};

package/types/java/io/Serializable/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/io/Writer/index.d.ts

@@ -0,0 +1,154 @@
+import type { String } from "../../lang/String";
+import type { CharSequence } from "../../lang/CharSequence";
+import type { Object } from "../../lang/Object";
+import type { Appendable } from "../../lang/Appendable";
+import type { Closeable } from "../Closeable";
+import type { Flushable } from "../Flushable";
+
+/**
+ * Abstract class for writing to character streams.  The only methods that a
+ *  subclass must implement are write(char[], int, int), flush(), and close().
+ *  Most subclasses, however, will override some of the methods defined here in
+ *  order to provide higher efficiency, additional functionality, or both.
+ * @see Writer
+ * @see BufferedWriter
+ * @see CharArrayWriter
+ * @see FilterWriter
+ * @see OutputStreamWriter
+ * @see FileWriter
+ * @see PipedWriter
+ * @see PrintWriter
+ * @see StringWriter
+ * @see Reader
+ * @author Mark Reinhold
+ * @since JDK1.1
+ */
+export type Writer = Object &
+  Appendable &
+  Closeable &
+  Flushable & {
+    /**
+     * Writes a single character.  The character to be written is contained in
+     *  the 16 low-order bits of the given integer value; the 16 high-order bits
+     *  are ignored.
+     *
+     *  <p> Subclasses that intend to support efficient single-character output
+     *  should override this method.
+     * @param c&#xA; int specifying a character to be written
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    write(c: number): void;
+
+    /**
+     * Writes an array of characters.
+     * @param cbuf&#xA; Array of characters to be written
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    write(cbuf: string[]): void;
+
+    /**
+     * Writes a portion of an array of characters.
+     * @param cbuf&#xA; Array of characters
+     * @param off&#xA; Offset from which to start writing characters
+     * @param len&#xA; Number of characters to write
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    write(cbuf: string[], off: number, len: number): void;
+
+    /**
+     * Writes a string.
+     * @param str&#xA; String to be written
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    write(str: String | string): void;
+
+    /**
+     * Writes a portion of a string.
+     * @param str&#xA; A String
+     * @param off&#xA; Offset from which to start writing characters
+     * @param len&#xA; Number of characters to write
+     * @throws IndexOutOfBoundsException&#xA; If <tt>off</tt> is negative, or <tt>len</tt> is negative,&#xA; or <tt>off+len</tt> is negative or greater than the length&#xA; of the given string
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    write(str: String | string, off: number, len: number): void;
+
+    /**
+     * Appends the specified character sequence to this writer.
+     *
+     *  <p> An invocation of this method of the form <tt>out.append(csq)</tt>
+     *  behaves in exactly the same way as the invocation
+     *
+     *  <pre>
+     *      out.write(csq.toString()) </pre>
+     *
+     *  <p> Depending on the specification of <tt>toString</tt> for the
+     *  character sequence <tt>csq</tt>, the entire sequence may not be
+     *  appended. For instance, invoking the <tt>toString</tt> method of a
+     *  character buffer will return a subsequence whose content depends upon
+     *  the buffer's position and limit.
+     * @param csq&#xA; The character sequence to append. If <tt>csq</tt> is&#xA; <tt>null</tt>, then the four characters <tt>"null"</tt> are&#xA; appended to this writer.
+     * @return This writer
+     * @throws IOException&#xA; If an I/O error occurs
+     * @since 1.5
+     */
+    append(csq: CharSequence): Writer;
+
+    /**
+     * Appends a subsequence of the specified character sequence to this writer.
+     *  <tt>Appendable</tt>.
+     *
+     *  <p> An invocation of this method of the form <tt>out.append(csq, start,
+     *  end)</tt> when <tt>csq</tt> is not <tt>null</tt> behaves in exactly the
+     *  same way as the invocation
+     *
+     *  <pre>
+     *      out.write(csq.subSequence(start, end).toString()) </pre>
+     * @param csq&#xA; The character sequence from which a subsequence will be&#xA; appended. If <tt>csq</tt> is <tt>null</tt>, then characters&#xA; will be appended as if <tt>csq</tt> contained the four&#xA; characters <tt>"null"</tt>.
+     * @param start&#xA; The index of the first character in the subsequence
+     * @param end&#xA; The index of the character following the last character in the&#xA; subsequence
+     * @return This writer
+     * @throws IndexOutOfBoundsException&#xA; If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>&#xA; is greater than <tt>end</tt>, or <tt>end</tt> is greater than&#xA; <tt>csq.length()</tt>
+     * @throws IOException&#xA; If an I/O error occurs
+     * @since 1.5
+     */
+    append(csq: CharSequence, start: number, end: number): Writer;
+
+    /**
+     * Appends the specified character to this writer.
+     *
+     *  <p> An invocation of this method of the form <tt>out.append(c)</tt>
+     *  behaves in exactly the same way as the invocation
+     *
+     *  <pre>
+     *      out.write(c) </pre>
+     * @param c&#xA; The 16-bit character to append
+     * @return This writer
+     * @throws IOException&#xA; If an I/O error occurs
+     * @since 1.5
+     */
+    append(c: string): Writer;
+
+    /**
+     * Flushes the stream.  If the stream has saved any characters from the
+     *  various write() methods in a buffer, write them immediately to their
+     *  intended destination.  Then, if that destination is another character or
+     *  byte stream, flush it.  Thus one flush() invocation will flush all the
+     *  buffers in a chain of Writers and OutputStreams.
+     *
+     *  <p> If the intended destination of this stream is an abstraction provided
+     *  by the underlying operating system, for example a file, then flushing the
+     *  stream guarantees only that bytes previously written to the stream are
+     *  passed to the operating system for writing; it does not guarantee that
+     *  they are actually written to a physical device such as a disk drive.
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    flush(): void;
+
+    /**
+     * Closes the stream, flushing it first. Once the stream has been closed,
+     *  further write() or flush() invocations will cause an IOException to be
+     *  thrown. Closing a previously closed stream has no effect.
+     * @throws IOException&#xA; If an I/O error occurs
+     */
+    close(): void;
+  };

package/types/java/io/Writer/index.js

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

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

@@ -0,0 +1,63 @@
+import type { CharSequence } from "../CharSequence";
+
+/**
+ * An object to which <tt>char</tt> sequences and values can be appended.  The
+ *  <tt>Appendable</tt> interface must be implemented by any class whose
+ *  instances are intended to receive formatted output from a {@link
+ *  java.util.Formatter}.
+ *
+ *  <p> The characters to be appended should be valid Unicode characters as
+ *  described in <a href="Character.html#unicode">Unicode Character
+ *  Representation</a>.  Note that supplementary characters may be composed of
+ *  multiple 16-bit <tt>char</tt> values.
+ *
+ *  <p> Appendables are not necessarily safe for multithreaded access.  Thread
+ *  safety is the responsibility of classes that extend and implement this
+ *  interface.
+ *
+ *  <p> Since this interface may be implemented by existing classes
+ *  with different styles of error handling there is no guarantee that
+ *  errors will be propagated to the invoker.
+ * @since 1.5
+ */
+export type Appendable = {
+  /**
+   * Appends the specified character sequence to this <tt>Appendable</tt>.
+   *
+   *  <p> Depending on which class implements the character sequence
+   *  <tt>csq</tt>, the entire sequence may not be appended.  For
+   *  instance, if <tt>csq</tt> is a {@link java.nio.CharBuffer} then
+   *  the subsequence to append is defined by the buffer's position and limit.
+   * @param csq&#xA; The character sequence to append. If <tt>csq</tt> is&#xA; <tt>null</tt>, then the four characters <tt>"null"</tt> are&#xA; appended to this Appendable.
+   * @return A reference to this <tt>Appendable</tt>
+   * @throws IOException&#xA; If an I/O error occurs
+   */
+  append(csq: CharSequence): Appendable;
+
+  /**
+   * Appends a subsequence of the specified character sequence to this
+   *  <tt>Appendable</tt>.
+   *
+   *  <p> An invocation of this method of the form <tt>out.append(csq, start,
+   *  end)</tt> when <tt>csq</tt> is not <tt>null</tt>, behaves in
+   *  exactly the same way as the invocation
+   *
+   *  <pre>
+   *      out.append(csq.subSequence(start, end)) </pre>
+   * @param csq&#xA; The character sequence from which a subsequence will be&#xA; appended. If <tt>csq</tt> is <tt>null</tt>, then characters&#xA; will be appended as if <tt>csq</tt> contained the four&#xA; characters <tt>"null"</tt>.
+   * @param start&#xA; The index of the first character in the subsequence
+   * @param end&#xA; The index of the character following the last character in the&#xA; subsequence
+   * @return A reference to this <tt>Appendable</tt>
+   * @throws IndexOutOfBoundsException&#xA; If <tt>start</tt> or <tt>end</tt> are negative, <tt>start</tt>&#xA; is greater than <tt>end</tt>, or <tt>end</tt> is greater than&#xA; <tt>csq.length()</tt>
+   * @throws IOException&#xA; If an I/O error occurs
+   */
+  append(csq: CharSequence, start: number, end: number): Appendable;
+
+  /**
+   * Appends the specified character to this <tt>Appendable</tt>.
+   * @param c&#xA; The character to append
+   * @return A reference to this <tt>Appendable</tt>
+   * @throws IOException&#xA; If an I/O error occurs
+   */
+  append(c: string): Appendable;
+};

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

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

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

@@ -0,0 +1,59 @@
+/**
+ * An object that may hold resources (such as file or socket handles)
+ *  until it is closed. The {@link #close()} method of an {@code AutoCloseable}
+ *  object is called automatically when exiting a {@code
+ *  try}-with-resources block for which the object has been declared in
+ *  the resource specification header. This construction ensures prompt
+ *  release, avoiding resource exhaustion exceptions and errors that
+ *  may otherwise occur.
+ * @apiNote <p>It is possible, and in fact common, for a base class to&#xA; implement AutoCloseable even though not all of its subclasses or&#xA; instances will hold releasable resources. For code that must operate&#xA; in complete generality, or when it is known that the {@code AutoCloseable}&#xA; instance requires resource release, it is recommended to use {@code&#xA; try}-with-resources constructions. However, when using facilities such as&#xA; {@link java.util.stream.Stream} that support both I/O-based and&#xA; non-I/O-based forms, {@code try}-with-resources blocks are in&#xA; general unnecessary when using non-I/O-based forms.
+ * @author Josh Bloch
+ * @since 1.7
+ */
+export type AutoCloseable = {
+  /**
+   * Closes this resource, relinquishing any underlying resources.
+   *  This method is invoked automatically on objects managed by the
+   *  {@code try}-with-resources statement.
+   *
+   *  <p>While this interface method is declared to throw {@code
+   *  Exception}, implementers are <em>strongly</em> encouraged to
+   *  declare concrete implementations of the {@code close} method to
+   *  throw more specific exceptions, or to throw no exception at all
+   *  if the close operation cannot fail.
+   *
+   *  <p> Cases where the close operation may fail require careful
+   *  attention by implementers. It is strongly advised to relinquish
+   *  the underlying resources and to internally <em>mark</em> the
+   *  resource as closed, prior to throwing the exception. The {@code
+   *  close} method is unlikely to be invoked more than once and so
+   *  this ensures that the resources are released in a timely manner.
+   *  Furthermore it reduces problems that could arise when the resource
+   *  wraps, or is wrapped, by another resource.
+   *
+   *  <p><em>Implementers of this interface are also strongly advised
+   *  to not have the {@code close} method throw {@link
+   *  InterruptedException}.</em>
+   *
+   *  This exception interacts with a thread's interrupted status,
+   *  and runtime misbehavior is likely to occur if an {@code
+   *  InterruptedException} is {@linkplain Throwable#addSuppressed
+   *  suppressed}.
+   *
+   *  More generally, if it would cause problems for an
+   *  exception to be suppressed, the {@code AutoCloseable.close}
+   *  method should not throw it.
+   *
+   *  <p>Note that unlike the {@link java.io.Closeable#close close}
+   *  method of {@link java.io.Closeable}, this {@code close} method
+   *  is <em>not</em> required to be idempotent.  In other words,
+   *  calling this {@code close} method more than once may have some
+   *  visible side effect, unlike {@code Closeable.close} which is
+   *  required to have no effect if called more than once.
+   *
+   *  However, implementers of this interface are strongly encouraged
+   *  to make their {@code close} methods idempotent.
+   * @throws Exception if this resource cannot be closed
+   */
+  close(): void;
+};

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

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

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

@@ -0,0 +1,208 @@
+import type { String } from "../String";
+
+import type { Object } from "../Object";
+import type { Serializable } from "../../io/Serializable";
+import type { Comparable } from "../Comparable";
+import type { Class } from "../Class";
+
+/**
+ * The Boolean class wraps a value of the primitive type
+ *  {@code boolean} in an object. An object of type
+ *  {@code Boolean} contains a single field whose type is
+ *  {@code boolean}.
+ *  <p>
+ *  In addition, this class provides many methods for
+ *  converting a {@code boolean} to a {@code String} and a
+ *  {@code String} to a {@code boolean}, as well as other
+ *  constants and methods useful when dealing with a
+ *  {@code boolean}.
+ * @author Arthur van Hoff
+ * @since JDK1.0
+ */
+export type Boolean = Object &
+  Serializable &
+  Comparable & {
+    /**
+     * Parses the string argument as a boolean.  The {@code boolean}
+     *  returned represents the value {@code true} if the string argument
+     *  is not {@code null} and is equal, ignoring case, to the string
+     *  {@code "true"}. <p>
+     *  Example: {@code Boolean.parseBoolean("True")} returns {@code true}.<br>
+     *  Example: {@code Boolean.parseBoolean("yes")} returns {@code false}.
+     * @param s the {@code String} containing the boolean&#xA; representation to be parsed
+     * @return the boolean represented by the string argument
+     * @since 1.5
+     */
+    parseBoolean(s: String | string): boolean;
+
+    /**
+     * Returns the value of this {@code Boolean} object as a boolean
+     *  primitive.
+     * @return the primitive {@code boolean} value of this object.
+     */
+    booleanValue(): boolean;
+
+    /**
+     * Returns a {@code Boolean} instance representing the specified
+     *  {@code boolean} value.  If the specified {@code boolean} value
+     *  is {@code true}, this method returns {@code Boolean.TRUE};
+     *  if it is {@code false}, this method returns {@code Boolean.FALSE}.
+     *  If a new {@code Boolean} instance is not required, this method
+     *  should generally be used in preference to the constructor
+     *  {@link #Boolean(boolean)}, as this method is likely to yield
+     *  significantly better space and time performance.
+     * @param b a boolean value.
+     * @return a {@code Boolean} instance representing {@code b}.
+     * @since 1.4
+     */
+    valueOf(b: boolean): boolean;
+
+    /**
+     * Returns a {@code Boolean} with a value represented by the
+     *  specified string.  The {@code Boolean} returned represents a
+     *  true value if the string argument is not {@code null}
+     *  and is equal, ignoring case, to the string {@code "true"}.
+     * @param s a string.
+     * @return the {@code Boolean} value represented by the string.
+     */
+    valueOf(s: String | string): boolean;
+
+    /**
+     * Returns a {@code String} object representing the specified
+     *  boolean.  If the specified boolean is {@code true}, then
+     *  the string {@code "true"} will be returned, otherwise the
+     *  string {@code "false"} will be returned.
+     * @param b the boolean to be converted
+     * @return the string representation of the specified {@code boolean}
+     * @since 1.4
+     */
+    toString(b: boolean): string;
+
+    /**
+     * Returns a {@code String} object representing this Boolean's
+     *  value.  If this object represents the value {@code true},
+     *  a string equal to {@code "true"} is returned. Otherwise, a
+     *  string equal to {@code "false"} is returned.
+     * @return a string representation of this object.
+     */
+    toString(): string;
+
+    /**
+     * Returns a hash code for this {@code Boolean} object.
+     * @return the integer {@code 1231} if this object represents&#xA; {@code true}; returns the integer {@code 1237} if this&#xA; object represents {@code false}.
+     */
+    hashCode(): number;
+
+    /**
+     * Returns a hash code for a {@code boolean} value; compatible with
+     *  {@code Boolean.hashCode()}.
+     * @param value the value to hash
+     * @return a hash code value for a {@code boolean} value.
+     * @since 1.8
+     */
+    hashCode(value: boolean): number;
+
+    /**
+     * Returns {@code true} if and only if the argument is not
+     *  {@code null} and is a {@code Boolean} object that
+     *  represents the same {@code boolean} value as this object.
+     * @param obj the object to compare with.
+     * @return {@code true} if the Boolean objects represent the&#xA; same value; {@code false} otherwise.
+     */
+    equals(obj: unknown): boolean;
+
+    /**
+     * Returns {@code true} if and only if the system property
+     *  named by the argument exists and is equal to the string
+     *  {@code "true"}. (Beginning with version 1.0.2 of the
+     *  Java<small><sup>TM</sup></small> platform, the test of
+     *  this string is case insensitive.) A system property is accessible
+     *  through {@code getProperty}, a method defined by the
+     *  {@code System} class.
+     *  <p>
+     *  If there is no property with the specified name, or if the specified
+     *  name is empty or null, then {@code false} is returned.
+     * @param name the system property name.
+     * @return the {@code boolean} value of the system property.
+     * @throws SecurityException for the same reasons as&#xA; {@link System#getProperty(String) System.getProperty}
+     * @see java.lang.System#getProperty(java.lang.String)
+     * @see java.lang.System#getProperty(java.lang.String, java.lang.String)
+     */
+    getBoolean(name: String | string): boolean;
+
+    /**
+     * Compares this {@code Boolean} instance with another.
+     * @param b the {@code Boolean} instance to be compared
+     * @return zero if this object represents the same boolean value as the&#xA; argument; a positive value if this object represents true&#xA; and the argument represents false; and a negative value if&#xA; this object represents false and the argument represents true
+     * @throws NullPointerException if the argument is {@code null}
+     * @see Comparable
+     * @since 1.5
+     */
+    compareTo(b: boolean): number;
+
+    /**
+     * Compares two {@code boolean} values.
+     *  The value returned is identical to what would be returned by:
+     *  <pre>
+     *     Boolean.valueOf(x).compareTo(Boolean.valueOf(y))
+     *  </pre>
+     * @param x the first {@code boolean} to compare
+     * @param y the second {@code boolean} to compare
+     * @return the value {@code 0} if {@code x == y};&#xA; a value less than {@code 0} if {@code !x && y}; and&#xA; a value greater than {@code 0} if {@code x && !y}
+     * @since 1.7
+     */
+    compare(x: boolean, y: boolean): number;
+
+    /**
+     * Returns the result of applying the logical AND operator to the
+     *  specified {@code boolean} operands.
+     * @param a the first operand
+     * @param b the second operand
+     * @return the logical AND of {@code a} and {@code b}
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    logicalAnd(a: boolean, b: boolean): boolean;
+
+    /**
+     * Returns the result of applying the logical OR operator to the
+     *  specified {@code boolean} operands.
+     * @param a the first operand
+     * @param b the second operand
+     * @return the logical OR of {@code a} and {@code b}
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    logicalOr(a: boolean, b: boolean): boolean;
+
+    /**
+     * Returns the result of applying the logical XOR operator to the
+     *  specified {@code boolean} operands.
+     * @param a the first operand
+     * @param b the second operand
+     * @return the logical XOR of {@code a} and {@code b}
+     * @see java.util.function.BinaryOperator
+     * @since 1.8
+     */
+    logicalXor(a: boolean, b: boolean): boolean;
+
+    /**
+ * The {@code Boolean} object corresponding to the primitive
+ *  value {@code true}.
+  
+    */
+    TRUE: boolean;
+
+    /**
+ * The {@code Boolean} object corresponding to the primitive
+ *  value {@code false}.
+  
+    */
+    FALSE: boolean;
+
+    /**
+     * The Class object representing the primitive type boolean.
+     * @since JDK1.1
+     */
+    TYPE: Class;
+  };