/**@class java.lang.Byte
 implements java.lang.Comparable

@extends java.lang.Number

 The wrapper for the primitive type {@code byte}.

 @since 1.1
*/
var Byte = {

/** The maximum {@code Byte} value, 2<sup>7</sup>-1.
*/
MAX_VALUE : "127",
/** The minimum {@code Byte} value, -2<sup>7</sup>.
*/
MIN_VALUE : "-128",
/** The number of bits needed to represent a {@code Byte} value in two's
 complement form.

 @since 1.5
*/
SIZE : "8",
/** The {@link java.lang.Class} object that represents the primitive type {@code byte}.
*/
TYPE : "null",
/**Gets the primitive value of this byte.
@return {Number} this object's primitive value.
*/
byteValue : function(  ) {},

/**Compares this object to the specified byte object to determine their
 relative order.
@param {Number} object
            the byte object to compare this object to.
@return {Number} a negative value if the value of this byte is less than the value
         of {@code object}; 0 if the value of this byte and the value of
         {@code object} are equal; a positive value if the value of this
         byte is greater than the value of {@code object}.
@see java.lang.Comparable
@since 1.2
*/
compareTo : function(  ) {},

/**Compares two {@code byte} values.
@return {Number} 0 if lhs = rhs, less than 0 if lhs &lt; rhs, and greater than 0 if lhs &gt; rhs.
@since 1.7
*/
compare : function(  ) {},

/**Parses the specified string and returns a {@code Byte} instance if the
 string can be decoded into a single byte value. The string may be an
 optional minus sign "-" followed by a hexadecimal ("0x..." or "#..."),
 octal ("0..."), or decimal ("...") representation of a byte.
@param {String} string
            a string representation of a single byte value.
@return {Number} a {@code Byte} containing the value represented by {@code string}.
@throws NumberFormatException
             if {@code string} cannot be parsed as a byte value.
*/
decode : function(  ) {},

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

/**Compares this object with the specified object and indicates if they are
 equal. In order to be equal, {@code object} must be an instance of
 {@code Byte} and have the same byte value as this object.
@param {Object {Object}} object
            the object to compare this byte with.
@return {Boolean} {@code true} if the specified object is equal to this
         {@code Byte}; {@code false} otherwise.
*/
equals : function(  ) {},

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

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

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

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

/**Parses the specified string as a signed decimal byte value. The ASCII
 character - ('-') is recognized as the minus sign.
@param {String} string
            the string representation of a single byte value.
@return {Number} the primitive byte value represented by {@code string}.
@throws NumberFormatException
             if {@code string} can not be parsed as a byte value.
*/
parseByte : function(  ) {},

/**Parses the specified string as a signed byte value using the specified
 radix. The ASCII character - ('-') is recognized as the minus sign.
@param {String} string
            the string representation of a single byte value.
@param {Number} radix
            the radix to use when parsing.
@return {Number} the primitive byte value represented by {@code string} using
         {@code radix}.
@throws NumberFormatException
             if {@code string} can not be parsed as a byte value, or
             {@code radix < Character.MIN_RADIX ||
             radix > Character.MAX_RADIX}.
*/
parseByte : function(  ) {},

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

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

/**Returns a two-digit hex string. That is, -1 becomes "ff" or "FF" and 2 becomes "02".
@hide internal use only
*/
toHexString : function(  ) {},

/**Returns a string containing a concise, human-readable description of the
 specified byte value.
@param {Number} value
            the byte to convert to a string.
@return {String} a printable representation of {@code value}.
*/
toString : function(  ) {},

/**Parses the specified string as a signed decimal byte value.
@param {String} string
            the string representation of a single byte value.
@return {Number} a {@code Byte} instance containing the byte value represented by
         {@code string}.
@throws NumberFormatException
             if {@code string} can not be parsed as a byte value.
@see #parseByte(String)
*/
valueOf : function(  ) {},

/**Parses the specified string as a signed byte value using the specified
 radix.
@param {String} string
            the string representation of a single byte value.
@param {Number} radix
            the radix to use when parsing.
@return {Number} a {@code Byte} instance containing the byte value represented by
         {@code string} using {@code radix}.
@throws NumberFormatException
             if {@code string} can not be parsed as a byte value, or
             {@code radix < Character.MIN_RADIX ||
             radix > Character.MAX_RADIX}.
@see #parseByte(String, int)
*/
valueOf : function(  ) {},

/**Returns a {@code Byte} instance for the specified byte value.
 <p>
 If it is not necessary to get a new {@code Byte} instance, it is
 recommended to use this method instead of the constructor, since it
 maintains a cache of instances which may result in better performance.
@param {Number} b
            the byte value to store in the instance.
@return {Number} a {@code Byte} instance containing {@code b}.
@since 1.5
*/
valueOf : function(  ) {},


};