@sitevision/api 2023.2.1 → 2023.2.2-beta.2

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,85 @@
+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 & {
+    /**
+     * 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 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 {@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;
+
+    /**
+     * 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;
+
+    /**
+ * 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;
+  };

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

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

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

@@ -0,0 +1,97 @@
+import type { String } from "../String";
+import type { IntStream } from "../../util/stream/IntStream";
+
+/**
+ * A <tt>CharSequence</tt> is a readable sequence of <code>char</code> values. This
+ *  interface provides uniform, read-only access to many different kinds of
+ *  <code>char</code> sequences.
+ *  A <code>char</code> value represents a character in the <i>Basic
+ *  Multilingual Plane (BMP)</i> or a surrogate. Refer to <a
+ *  href="Character.html#unicode">Unicode Character Representation</a> for details.
+ *
+ *  <p> This interface does not refine the general contracts of the {@link
+ *  java.lang.Object#equals(java.lang.Object) equals} and {@link
+ *  java.lang.Object#hashCode() hashCode} methods.  The result of comparing two
+ *  objects that implement <tt>CharSequence</tt> is therefore, in general,
+ *  undefined.  Each object may be implemented by a different class, and there
+ *  is no guarantee that each class will be capable of testing its instances
+ *  for equality with those of the other.  It is therefore inappropriate to use
+ *  arbitrary <tt>CharSequence</tt> instances as elements in a set or as keys in
+ *  a map. </p>
+ * @author Mike McCloskey
+ * @since 1.4
+ * @spec JSR-51
+ */
+export type CharSequence = {
+  /**
+   * Returns the length of this character sequence.  The length is the number
+   *  of 16-bit <code>char</code>s in the sequence.
+   * @return the number of <code>char</code>s in this sequence
+   */
+  length(): number;
+
+  /**
+   * Returns the <code>char</code> value at the specified index.  An index ranges from zero
+   *  to <tt>length() - 1</tt>.  The first <code>char</code> value of the sequence is at
+   *  index zero, the next at index one, and so on, as for array
+   *  indexing.
+   *
+   *  <p>If the <code>char</code> value specified by the index is a
+   *  <a href="{@docRoot}/java/lang/Character.html#unicode">surrogate</a>, the surrogate
+   *  value is returned.
+   * @param index the index of the <code>char</code> value to be returned
+   * @return the specified <code>char</code> value
+   * @throws IndexOutOfBoundsException&#xA; if the <tt>index</tt> argument is negative or not less than&#xA; <tt>length()</tt>
+   */
+  charAt(index: number): string;
+
+  /**
+   * Returns a <code>CharSequence</code> that is a subsequence of this sequence.
+   *  The subsequence starts with the <code>char</code> value at the specified index and
+   *  ends with the <code>char</code> value at index <tt>end - 1</tt>.  The length
+   *  (in <code>char</code>s) of the
+   *  returned sequence is <tt>end - start</tt>, so if <tt>start == end</tt>
+   *  then an empty sequence is returned.
+   * @param start the start index, inclusive
+   * @param end the end index, exclusive
+   * @return the specified subsequence
+   * @throws IndexOutOfBoundsException&#xA; if <tt>start</tt> or <tt>end</tt> are negative,&#xA; if <tt>end</tt> is greater than <tt>length()</tt>,&#xA; or if <tt>start</tt> is greater than <tt>end</tt>
+   */
+  subSequence(start: number, end: number): CharSequence;
+
+  /**
+   * Returns a string containing the characters in this sequence in the same
+   *  order as this sequence.  The length of the string will be the length of
+   *  this sequence.
+   * @return a string consisting of exactly this sequence of characters
+   */
+  toString(): string;
+
+  /**
+   * Returns a stream of {@code int} zero-extending the {@code char} values
+   *  from this sequence.  Any char which maps to a <a
+   *  href="{@docRoot}/java/lang/Character.html#unicode">surrogate code
+   *  point</a> is passed through uninterpreted.
+   *
+   *  <p>If the sequence is mutated while the stream is being read, the
+   *  result is undefined.
+   * @return an IntStream of char values from this sequence
+   * @since 1.8
+   */
+  chars(): IntStream;
+
+  /**
+   * Returns a stream of code point values from this sequence.  Any surrogate
+   *  pairs encountered in the sequence are combined as if by {@linkplain
+   *  Character#toCodePoint Character.toCodePoint} and the result is passed
+   *  to the stream. Any other code units, including ordinary BMP characters,
+   *  unpaired surrogates, and undefined code units, are zero-extended to
+   *  {@code int} values which are then passed to the stream.
+   *
+   *  <p>If the sequence is mutated while the stream is being read, the result
+   *  is undefined.
+   * @return an IntStream of Unicode code points from this sequence
+   * @since 1.8
+   */
+  codePoints(): IntStream;
+};