/**@class java.lang.Throwable
 implements java.io.Serializable

@extends java.lang.Object

 The superclass of all classes which can be thrown by the VM. The
 two direct subclasses are recoverable exceptions ({@code Exception}) and
 unrecoverable errors ({@code Error}). This class provides common methods for
 accessing a string message which provides extra information about the
 circumstances in which the {@code Throwable} was created (basically an error
 message in most cases), and for saving a stack trace (that is, a record of
 the call stack at a particular point in time) which can be printed later.

 <p>A {@code Throwable} can also include a cause, which is a nested {@code
 Throwable} that represents the original problem that led to this {@code
 Throwable}. It is often used for wrapping various types of errors into a
 common {@code Throwable} without losing the detailed original error
 information. When printing the stack trace, the trace of the cause is
 included.

 @see Error
 @see Exception
 @see RuntimeException
*/
var Throwable = {

/**Records the stack trace from the point where this method has been called
 to this {@code Throwable}. This method is invoked by the {@code Throwable} constructors.

 <p>This method is public so that code (such as an RPC system) which catches
 a {@code Throwable} and then re-throws it can replace the construction-time stack trace
 with a stack trace from the location where the exception was re-thrown, by <i>calling</i>
 {@code fillInStackTrace}.

 <p>This method is non-final so that non-Java language implementations can disable VM stack
 traces for their language. Filling in the stack trace is relatively expensive.
 <i>Overriding</i> this method in the root of a language's exception hierarchy allows the
 language to avoid paying for something it doesn't need.
@return {Object {java.lang.Throwable}} this {@code Throwable} instance.
*/
fillInStackTrace : function(  ) {},

/**Returns the detail message which was provided when this
 {@code Throwable} was created. Returns {@code null} if no message was
 provided at creation time.
*/
getMessage : function(  ) {},

/**Returns the detail message which was provided when this
 {@code Throwable} was created. Returns {@code null} if no message was
 provided at creation time. Subclasses may override this method to return
 localized text for the message. Android returns the regular detail message.
*/
getLocalizedMessage : function(  ) {},

/**Returns a clone of the array of stack trace elements of this {@code Throwable}. Each
 {@code StackTraceElement} represents an entry in the call stack. The
 element at position 0 is the top of the stack, that is, the stack frame
 where this {@code Throwable} is thrown.
@see #printStackTrace()
*/
getStackTrace : function(  ) {},

/**Sets the array of stack trace elements. Each {@code StackTraceElement}
 represents an entry in the call stack. A copy of the specified array is
 stored in this {@code Throwable}. will be returned by {@code
 getStackTrace()} and printed by {@code printStackTrace()}.
@param {Object {java.lang.StackTraceElement[]}} trace
            the new array of {@code StackTraceElement}s. A copy of the
            array is stored in this {@code Throwable}, so subsequent
            changes to {@code trace} will not change the call stack stored
            in this {@code Throwable}.
@throws NullPointerException
             if any element in {@code trace} is {@code null}.
@see #printStackTrace()
*/
setStackTrace : function(  ) {},

/**Writes a printable representation of this {@code Throwable}'s stack trace
 to the {@code System.err} stream.
*/
printStackTrace : function(  ) {},

/**Writes a printable representation of this {@code Throwable}'s stack trace
 to the given print stream. If the {@code Throwable} contains a
 {@link #getCause() cause}, the method will be invoked recursively for
 the nested {@code Throwable}.
*/
printStackTrace : function(  ) {},

/**Writes a printable representation of this {@code Throwable}'s stack trace
 to the specified print writer. If the {@code Throwable} contains a
 {@link #getCause() cause}, the method will be invoked recursively for the
 nested {@code Throwable}.
@param {Object {PrintWriter}} err
            the writer to write the stack trace on.
*/
printStackTrace : function(  ) {},

/**
*/
toString : function(  ) {},

/**Initializes the cause of this {@code Throwable}. The cause can only be
 initialized once.
@param {Object {Throwable}} throwable
            the cause of this {@code Throwable}.
@return {Object {java.lang.Throwable}} this {@code Throwable} instance.
@throws IllegalArgumentException
             if {@code Throwable} is this object.
@throws IllegalStateException
             if the cause has already been initialized.
*/
initCause : function(  ) {},

/**Returns the cause of this {@code Throwable}, or {@code null} if there is
 no cause.
*/
getCause : function(  ) {},

/**Adds {@code throwable} to the list of throwables suppressed by this. The
 throwable will included when this exception's stack trace is printed.
@throws IllegalArgumentException if {@code throwable == this}.
@throws NullPointerException if {@code throwable == null}.
@since 1.7
*/
addSuppressed : function(  ) {},

/**Returns the throwables suppressed by this.
@since 1.7
*/
getSuppressed : function(  ) {},


};