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

 implements java.lang.Comparable

 implements java.lang.CharSequence

@extends java.lang.Object

 An immutable sequence of UTF-16 {@code char}s.
 See {@link java.lang.Character} for details about the relationship between {@code char} and
 Unicode code points.

 @see StringBuffer
 @see StringBuilder
 @see Charset
 @since 1.0
*/
var String = {

/** Compares strings using {@link #compareToIgnoreCase}.
 This is not suitable for case-insensitive string comparison for all locales.
 Use a {@link java.text.Collator} instead.
*/
CASE_INSENSITIVE_ORDER : "null",
/**Returns the {@code char} at {@code index}.
@throws IndexOutOfBoundsException if {@code index < 0} or {@code index >= length()}.
*/
charAt : function(  ) {},

/**Compares this string to the given string.

 <p>The strings are compared one {@code char} at a time.
 In the discussion of the return value below, note that {@code char} does not
 mean code point, though this should only be visible for surrogate pairs.

 <p>If there is an index at which the two strings differ, the result is
 the difference between the two {@code char}s at the lowest such index.
 If not, but the lengths of the strings differ, the result is the difference
 between the two strings' lengths.
 If the strings are the same length and every {@code char} is the same, the result is 0.
@throws NullPointerException
             if {@code string} is {@code null}.
*/
compareTo : function(  ) {},

/**Compares this string to the given string, ignoring case differences.

 <p>The strings are compared one {@code char} at a time. This is not suitable
 for case-insensitive string comparison for all locales.
 Use a {@link java.text.Collator} instead.

 <p>If there is an index at which the two strings differ, the result is
 the difference between the two {@code char}s at the lowest such index.
 If not, but the lengths of the strings differ, the result is the difference
 between the two strings' lengths.
 If the strings are the same length and every {@code char} is the same, the result is 0.
@throws NullPointerException
             if {@code string} is {@code null}.
*/
compareToIgnoreCase : function(  ) {},

/**Concatenates this string and the specified string.
@param {String} string
            the string to concatenate
@return {String} a new string which is the concatenation of this string and the
         specified string.
*/
concat : function(  ) {},

/**Creates a new string by copying the given {@code char[]}.
 Modifying the array after creating the string has no
 effect on the string.
@throws NullPointerException
             if {@code data} is {@code null}.
*/
copyValueOf : function(  ) {},

/**Creates a new string by copying the given subsequence of the given {@code char[]}.
 Modifying the array after creating the string has no
 effect on the string.
@throws NullPointerException
             if {@code data} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code length < 0, start < 0} or {@code start + length >
             data.length}.
*/
copyValueOf : function(  ) {},

/**Compares the specified string to this string to determine if the
 specified string is a suffix.
@throws NullPointerException
             if {@code suffix} is {@code null}.
*/
endsWith : function(  ) {},

/**Compares the given object to this string and returns true if they are
 equal. The object must be an instance of {@code String} with the same length,
 where for every index, {@code charAt} on each string returns the same value.
*/
equals : function(  ) {},

/**Compares the given string to this string ignoring case.

 <p>The strings are compared one {@code char} at a time. This is not suitable
 for case-insensitive string comparison for all locales.
 Use a {@link java.text.Collator} instead.
*/
equalsIgnoreCase : function(  ) {},

/**Mangles a subsequence of this string into a byte array by stripping the high order bits from
 each {@code char}. Use {@link #getBytes}() or {@link #getBytes}(String) instead.
@param {Number} start
            the start offset in this string.
@param {Number} end
            the end+1 offset in this string.
@param {Object {byte[]}} data
            the destination byte array.
@param {Number} index
            the start offset in the destination byte array.
@throws NullPointerException
             if {@code data} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code start < 0}, {@code end > length()}, {@code index <
             0} or {@code end - start > data.length - index}.
@deprecated Use {@link #getBytes()} or {@link #getBytes(String)}
*/
getBytes : function(  ) {},

/**Returns a new byte array containing the code points in this string encoded using the
 system's {@link java.nio.charset.Charset#defaultCharset default charset}.

 <p>The behavior when this string cannot be represented in the system's default charset
 is unspecified. In practice, when the default charset is UTF-8 (as it is on Android),
 all strings can be encoded.
*/
getBytes : function(  ) {},

/**Returns a new byte array containing the code points of this string encoded using the
 named charset.

 <p>The behavior when this string cannot be represented in the named charset
 is unspecified. Use {@link java.nio.charset.CharsetEncoder} for more control.
@throws UnsupportedEncodingException if the charset is not supported
*/
getBytes : function(  ) {},

/**Returns a new byte array containing the code points of this string encoded using the
 given charset.

 <p>The behavior when this string cannot be represented in the given charset
 is to replace malformed input and unmappable code points with the charset's default
 replacement byte array. Use {@link java.nio.charset.CharsetEncoder} for more control.
@since 1.6
*/
getBytes : function(  ) {},

/**Copies the given subsequence of this string to the given array
 starting at the given offset.
@param {Number} start
            the start offset in this string.
@param {Number} end
            the end+1 offset in this string.
@param {Object {char[]}} buffer
            the destination array.
@param {Number} index
            the start offset in the destination array.
@throws NullPointerException
             if {@code buffer} is {@code null}.
@throws IndexOutOfBoundsException
             if {@code start < 0}, {@code end > length()}, {@code start >
             end}, {@code index < 0}, {@code end - start > buffer.length -
             index}
*/
getChars : function(  ) {},

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

/**Returns the first index of the given code point, or -1.
 The search starts at the beginning and moves towards
 the end of this string.
*/
indexOf : function(  ) {},

/**Returns the next index of the given code point, or -1. The
 search starts at the given offset and moves towards
 the end of this string.
*/
indexOf : function(  ) {},

/**Returns the first index of the given string, or -1. The
 search starts at the beginning and moves towards the end
 of this string.
@throws NullPointerException
             if {@code string} is {@code null}.
*/
indexOf : function(  ) {},

/**Returns the next index of the given string in this string, or -1. The search
 for the string starts at the given offset and moves towards the end
 of this string.
@throws NullPointerException
             if {@code subString} is {@code null}.
*/
indexOf : function(  ) {},

/**Returns an interned string equal to this string. The VM maintains an internal set of
 unique strings. All string literals found in loaded classes'
 constant pools are automatically interned. Manually-interned strings are only weakly
 referenced, so calling {@code intern} won't lead to unwanted retention.

 <p>Interning is typically used because it guarantees that for interned strings
 {@code a} and {@code b}, {@code a.equals(b)} can be simplified to
 {@code a == b}. (This is not true of non-interned strings.)

 <p>Many applications find it simpler and more convenient to use an explicit
 {@link java.util.HashMap} to implement their own pools.
*/
intern : function(  ) {},

/**Returns true if the length of this string is 0.
@since 1.6
*/
isEmpty : function(  ) {},

/**Returns the last index of the code point {@code c}, or -1.
 The search starts at the end and moves towards the
 beginning of this string.
*/
lastIndexOf : function(  ) {},

/**Returns the last index of the code point {@code c}, or -1.
 The search starts at offset {@code start} and moves towards
 the beginning of this string.
*/
lastIndexOf : function(  ) {},

/**Returns the index of the start of the last match for the given string in this string, or -1.
 The search for the string starts at the end and moves towards the beginning
 of this string.
@throws NullPointerException
             if {@code string} is {@code null}.
*/
lastIndexOf : function(  ) {},

/**Returns the index of the start of the previous match for the given string in this string,
 or -1.
 The search for the string starts at the given index and moves towards the beginning
 of this string.
@throws NullPointerException
             if {@code subString} is {@code null}.
*/
lastIndexOf : function(  ) {},

/**Returns the number of {@code char}s in this string. If this string contains surrogate pairs,
 this is not the same as the number of code points.
*/
length : function(  ) {},

/**Returns true if the given subsequence of the given string matches this string starting
 at the given offset.
@param {Number} thisStart the start offset in this string.
@param {String} string the other string.
@param {Number} start the start offset in {@code string}.
@param {Number} length the number of {@code char}s to compare.
@throws NullPointerException
             if {@code string} is {@code null}.
*/
regionMatches : function(  ) {},

/**Returns true if the given subsequence of the given string matches this string starting
 at the given offset.

 <p>If ignoreCase is true, case is ignored during the comparison.
 The strings are compared one {@code char} at a time. This is not suitable
 for case-insensitive string comparison for all locales.
 Use a {@link java.text.Collator} instead.
@param {Boolean} ignoreCase
     specifies if case should be ignored (use {@link java.text.Collator} instead for
     non-ASCII case insensitivity).
@param {Number} thisStart the start offset in this string.
@param {String} string the other string.
@param {Number} start the start offset in {@code string}.
@param {Number} length the number of {@code char}s to compare.
@throws NullPointerException
             if {@code string} is {@code null}.
*/
regionMatches : function(  ) {},

/**Returns a copy of this string after replacing occurrences of the given {@code char} with another.
*/
replace : function(  ) {},

/**Returns a copy of this string after replacing occurrences of {@code target} replaced
 with {@code replacement}. The string is processed from the beginning to the
 end.
@throws NullPointerException
             if {@code target} or {@code replacement} is {@code null}.
*/
replace : function(  ) {},

/**Compares the specified string to this string to determine if the
 specified string is a prefix.
@param {String} prefix
            the string to look for.
@return {Boolean} {@code true} if the specified string is a prefix of this string,
         {@code false} otherwise
@throws NullPointerException
             if {@code prefix} is {@code null}.
*/
startsWith : function(  ) {},

/**Compares the specified string to this string, starting at the specified
 offset, to determine if the specified string is a prefix.
@param {String} prefix
            the string to look for.
@param {Number} start
            the starting offset.
@return {Boolean} {@code true} if the specified string occurs in this string at the
         specified offset, {@code false} otherwise.
@throws NullPointerException
             if {@code prefix} is {@code null}.
*/
startsWith : function(  ) {},

/**Returns a string containing a suffix of this string starting at {@code start}.
 The returned string shares this string's <a href="#backing_array">backing array</a>.
@throws IndexOutOfBoundsException
             if {@code start < 0} or {@code start > length()}.
*/
substring : function(  ) {},

/**Returns a string containing the given subsequence of this string.
 The returned string shares this string's <a href="#backing_array">backing array</a>.
@param {Number} start the start offset.
@param {Number} end the end+1 offset.
@throws IndexOutOfBoundsException
             if {@code start < 0}, {@code start > end} or {@code end > length()}.
*/
substring : function(  ) {},

/**Returns a new {@code char} array containing a copy of the {@code char}s in this string.
 This is expensive and rarely useful. If you just want to iterate over the {@code char}s in
 the string, use {@link #charAt} instead.
*/
toCharArray : function(  ) {},

/**Converts this string to lower case, using the rules of the user's default locale.
 See "<a href="../util/Locale.html#default_locale">Be wary of the default locale</a>".
@return {String} a new lower case string, or {@code this} if it's already all lower case.
*/
toLowerCase : function(  ) {},

/**Converts this string to lower case, using the rules of {@code locale}.

 <p>Most case mappings are unaffected by the language of a {@code Locale}. Exceptions include
 dotted and dotless I in Azeri and Turkish locales, and dotted and dotless I and J in
 Lithuanian locales. On the other hand, it isn't necessary to provide a Greek locale to get
 correct case mapping of Greek characters: any locale will do.

 <p>See <a href="http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt">http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt</a>
 for full details of context- and language-specific special cases.
@return {String} a new lower case string, or {@code this} if it's already all lower case.
*/
toLowerCase : function(  ) {},

/**Returns this string.
*/
toString : function(  ) {},

/**Converts this this string to upper case, using the rules of the user's default locale.
 See "<a href="../util/Locale.html#default_locale">Be wary of the default locale</a>".
@return {String} a new upper case string, or {@code this} if it's already all upper case.
*/
toUpperCase : function(  ) {},

/**Converts this this string to upper case, using the rules of {@code locale}.

 <p>Most case mappings are unaffected by the language of a {@code Locale}. Exceptions include
 dotted and dotless I in Azeri and Turkish locales, and dotted and dotless I and J in
 Lithuanian locales. On the other hand, it isn't necessary to provide a Greek locale to get
 correct case mapping of Greek characters: any locale will do.

 <p>See <a href="http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt">http://www.unicode.org/Public/UNIDATA/SpecialCasing.txt</a>
 for full details of context- and language-specific special cases.
@return {String} a new upper case string, or {@code this} if it's already all upper case.
*/
toUpperCase : function(  ) {},

/**Returns a string with no code points <code><= \\u0020</code> at
 the beginning or end.
*/
trim : function(  ) {},

/**Returns a new string containing the same {@code char}s as the given
 array. Modifying the array after creating the string has no
 effect on the string.
@throws NullPointerException
             if {@code data} is {@code null}.
*/
valueOf : function(  ) {},

/**Returns a new string containing the same {@code char}s as the given
 subset of the given array. Modifying the array after creating the string has no
 effect on the string.
@throws IndexOutOfBoundsException
             if {@code length < 0}, {@code start < 0} or {@code start + length > data.length}
@throws NullPointerException
             if {@code data} is {@code null}.
*/
valueOf : function(  ) {},

/**Returns a new string of just the given {@code char}.
*/
valueOf : function(  ) {},

/**Returns the string representation of the given double.
*/
valueOf : function(  ) {},

/**Returns the string representation of the given float.
*/
valueOf : function(  ) {},

/**Returns the string representation of the given int.
*/
valueOf : function(  ) {},

/**Returns the string representation of the given long.
*/
valueOf : function(  ) {},

/**Converts the specified object to its string representation. If the object
 is null return the string {@code "null"}, otherwise use {@code
 toString()} to get the string representation.
@param {Object {Object}} value
            the object.
@return {String} the object converted to a string, or the string {@code "null"}.
*/
valueOf : function(  ) {},

/**Converts the specified boolean to its string representation. When the
 boolean is {@code true} return {@code "true"}, otherwise return {@code
 "false"}.
@param {Boolean} value
            the boolean.
@return {String} the boolean converted to a string.
*/
valueOf : function(  ) {},

/**Returns true if the {@code char}s in the given {@code StringBuffer} are the same
 as those in this string.
@throws NullPointerException
             if {@code sb} is {@code null}.
@since 1.4
*/
contentEquals : function(  ) {},

/**Returns true if the {@code char}s in the given {@code CharSequence} are the same
 as those in this string.
@since 1.5
*/
contentEquals : function(  ) {},

/**Tests whether this string matches the given {@code regularExpression}. This method returns
 true only if the regular expression matches the <i>entire</i> input string. A common mistake is
 to assume that this method behaves like {@link #contains}; if you want to match anywhere
 within the input string, you need to add {@code .*} to the beginning and end of your
 regular expression. See {@link Pattern#matches}.

 <p>If the same regular expression is to be used for multiple operations, it may be more
 efficient to reuse a compiled {@code Pattern}.
@throws PatternSyntaxException
             if the syntax of the supplied regular expression is not
             valid.
@throws NullPointerException if {@code regularExpression == null}
@since 1.4
*/
matches : function(  ) {},

/**Replaces all matches for {@code regularExpression} within this string with the given
 {@code replacement}.
 See {@link Pattern} for regular expression syntax.

 <p>If the same regular expression is to be used for multiple operations, it may be more
 efficient to reuse a compiled {@code Pattern}.
@throws PatternSyntaxException
             if the syntax of the supplied regular expression is not
             valid.
@throws NullPointerException if {@code regularExpression == null}
@see Pattern
@since 1.4
*/
replaceAll : function(  ) {},

/**Replaces the first match for {@code regularExpression} within this string with the given
 {@code replacement}.
 See {@link Pattern} for regular expression syntax.

 <p>If the same regular expression is to be used for multiple operations, it may be more
 efficient to reuse a compiled {@code Pattern}.
@throws PatternSyntaxException
             if the syntax of the supplied regular expression is not
             valid.
@throws NullPointerException if {@code regularExpression == null}
@see Pattern
@since 1.4
*/
replaceFirst : function(  ) {},

/**Splits this string using the supplied {@code regularExpression}.
 Equivalent to {@code split(regularExpression, 0)}.
 See {@link Pattern#split(CharSequence, int)} for an explanation of {@code limit}.
 See {@link Pattern} for regular expression syntax.

 <p>If the same regular expression is to be used for multiple operations, it may be more
 efficient to reuse a compiled {@code Pattern}.
@throws NullPointerException if {@code regularExpression ==  null}
@throws PatternSyntaxException
             if the syntax of the supplied regular expression is not
             valid.
@see Pattern
@since 1.4
*/
split : function(  ) {},

/**Splits this string using the supplied {@code regularExpression}.
 See {@link Pattern#split(CharSequence, int)} for an explanation of {@code limit}.
 See {@link Pattern} for regular expression syntax.

 <p>If the same regular expression is to be used for multiple operations, it may be more
 efficient to reuse a compiled {@code Pattern}.
@throws NullPointerException if {@code regularExpression ==  null}
@throws PatternSyntaxException
             if the syntax of the supplied regular expression is not
             valid.
@since 1.4
*/
split : function(  ) {},

/**Equivalent to {@link #substring(int, int)} but needed to implement {@code CharSequence}.
@throws IndexOutOfBoundsException
             if {@code start < 0}, {@code end < 0}, {@code start > end} or
             {@code end > length()}.
@see java.lang.CharSequence#subSequence(int, int)
@since 1.4
*/
subSequence : function(  ) {},

/**Returns the Unicode code point at the given {@code index}.
@throws IndexOutOfBoundsException if {@code index < 0 || index >= length()}
@see Character#codePointAt(char[], int, int)
@since 1.5
*/
codePointAt : function(  ) {},

/**Returns the Unicode code point that precedes the given {@code index}.
@throws IndexOutOfBoundsException if {@code index < 1 || index > length()}
@see Character#codePointBefore(char[], int, int)
@since 1.5
*/
codePointBefore : function(  ) {},

/**Calculates the number of Unicode code points between {@code start}
 and {@code end}.
@param {Number} start
            the inclusive beginning index of the subsequence.
@param {Number} end
            the exclusive end index of the subsequence.
@return {Number} the number of Unicode code points in the subsequence.
@throws IndexOutOfBoundsException
         if {@code start < 0 || end > length() || start > end}
@see Character#codePointCount(CharSequence, int, int)
@since 1.5
*/
codePointCount : function(  ) {},

/**Returns true if this string contains the {@code chars}s from the given {@code CharSequence}.
@since 1.5
*/
contains : function(  ) {},

/**Returns the index within this object that is offset from {@code index} by
 {@code codePointOffset} code points.
@param {Number} index
            the index within this object to calculate the offset from.
@param {Number} codePointOffset
            the number of code points to count.
@return {Number} the index within this object that is the offset.
@throws IndexOutOfBoundsException
             if {@code index} is negative or greater than {@code length()}
             or if there aren't enough code points before or after {@code
             index} to match {@code codePointOffset}.
@since 1.5
*/
offsetByCodePoints : function(  ) {},

/**Returns a localized formatted string, using the supplied format and arguments,
 using the user's default locale.

 <p>If you're formatting a string other than for human
 consumption, you should use the {@code format(Locale, String, Object...)}
 overload and supply {@code Locale.US}. See
 "<a href="../util/Locale.html#default_locale">Be wary of the default locale</a>".
@param {String} format the format string (see {@link java.util.Formatter#format})
@param {Object {java.lang.Object[]}} args
            the list of arguments passed to the formatter. If there are
            more arguments than required by {@code format},
            additional arguments are ignored.
@return {String} the formatted string.
@throws NullPointerException if {@code format == null}
@throws java.util.IllegalFormatException
             if the format is invalid.
@since 1.5
*/
format : function(  ) {},

/**Returns a formatted string, using the supplied format and arguments,
 localized to the given locale.
@param {Object {Locale}} locale
            the locale to apply; {@code null} value means no localization.
@param {String} format the format string (see {@link java.util.Formatter#format})
@param {Object {java.lang.Object[]}} args
            the list of arguments passed to the formatter. If there are
            more arguments than required by {@code format},
            additional arguments are ignored.
@return {String} the formatted string.
@throws NullPointerException if {@code format == null}
@throws java.util.IllegalFormatException
             if the format is invalid.
@since 1.5
*/
format : function(  ) {},


};