j4ts

export declare namespace javaemul.internal { /** * Private implementation class for GWT. This API should not be * considered public or stable. * @class */ class Coercions { /** * Coerce js int to 32 bits. * Trick related to JS and lack of integer rollover. * {@see com.google.gwt.lang.Cast#narrow_int} * @param {number} value * @return {number} */ static ensureInt(value: number): number; constructor(); } } export declare namespace javaemul.internal { class JreHelper { static LOG10E: number; static LOG10E_$LI$(): number; } } export declare namespace javaemul.internal { /** * Wraps native <code>boolean</code> as an object. * @param {boolean} value * @class */ class BooleanHelper implements java.lang.Comparable<BooleanHelper>, java.io.Serializable { static FALSE: boolean; static TRUE: boolean; static TYPE: any; static TYPE_$LI$(): any; static compare(x: boolean, y: boolean): number; static hashCode(value: boolean): number; static logicalAnd(a: boolean, b: boolean): boolean; static logicalOr(a: boolean, b: boolean): boolean; static logicalXor(a: boolean, b: boolean): boolean; static parseBoolean(s: string): boolean; static toString(x: boolean): string; static valueOf$boolean(b: boolean): boolean; static valueOf$java_lang_String(s: string): boolean; static valueOf(s?: any): any; booleanValue(): boolean; static unsafeCast(value: any): boolean; compareTo$javaemul_internal_BooleanHelper(b: BooleanHelper): number; /** * * @param {javaemul.internal.BooleanHelper} b * @return {number} */ compareTo(b?: any): any; /** * * @param {*} o * @return {boolean} */ equals(o: any): boolean; /** * * @return {number} */ hashCode(): number; /** * * @return {string} */ toString(): string; constructor(); } } export declare namespace javaemul.internal { /** * Hashcode caching for strings. * @class */ class StringHashCache { /** * The "old" cache; it will be dumped when front is full. */ static back: any; static back_$LI$(): any; /** * Tracks the number of entries in front. */ static count: number; /** * The "new" cache; it will become back when it becomes full. */ static front: any; static front_$LI$(): any; /** * Pulled this number out of thin air. */ static MAX_CACHE: number; static getHashCode(str: string): number; static compute(str: string): number; static increment(): void; static getProperty(map: any, key: string): any; static createNativeObject(): any; static unsafeCastToInt(o: any): number; } } export declare namespace javaemul.internal.stream { class ConsumingFunction<T> { consumer: (p1: T) => void; constructor(consumer: (p1: T) => void); /** * * @param {*} t * @return {*} */ apply(t: T): T; } } export declare namespace javaemul.internal.stream { abstract class TerminalStreamRow implements javaemul.internal.stream.StreamRow { chain(next: javaemul.internal.stream.StreamRow): void; end(): void; abstract item(a?: any): any; constructor(); } } export declare namespace javaemul.internal.stream { class RunnableChain { run: () => void; next: RunnableChain; constructor(run: () => void); chain(next: RunnableChain): void; runChain(): void; } } export declare namespace javaemul.internal.stream { interface StreamRow { chain(next: StreamRow): any; item(a: any): boolean; end(): any; } } export declare namespace javaemul.internal.stream { class QuiteRunnable { loudRunnable: () => void; constructor(loudRunnable: () => void); /** * */ run(): void; } } export declare namespace javaemul.internal.stream { class ChooseSmallest<T> { comparator: java.util.Comparator<T>; constructor(comparator: java.util.Comparator<T>); apply(t1: T, t2: T): T; } } export declare namespace javaemul.internal.stream { class StreamHelper<T> implements java.util.stream.Stream<T> { onCloseChain: javaemul.internal.stream.RunnableChain; head: javaemul.internal.stream.StreamRow; end: javaemul.internal.stream.StreamRow; data: java.util.Collection<T>; chain(streamRow: javaemul.internal.stream.StreamRow): java.util.stream.Stream<any>; play(): void; foldRight(identity: java.util.Optional<T>, accumulator: any): java.util.Optional<any>; constructor(data: java.util.Collection<T>); filter(predicate: (p1: any) => boolean): java.util.stream.Stream<T>; map<R>(mapper: (p1: any) => any): java.util.stream.Stream<R>; mapToObj(mapper: (p0: number) => any): java.util.stream.Stream; flatMap<R>(mapper: (p1: any) => any): java.util.stream.Stream<R>; distinct(): java.util.stream.Stream<T>; sorted$(): java.util.stream.Stream<T>; sorted$java_util_Comparator(comparator: java.util.Comparator<any>): java.util.stream.Stream<T>; sorted(comparator?: any): any; peek(action: (p1: any) => void): java.util.stream.Stream<T>; limit(maxSize: number): java.util.stream.Stream<T>; skip(n: number): java.util.stream.Stream<T>; forEach(action: (p1: any) => void): void; forEachOrdered(action: (p1: any) => void): void; toArray$(): any[]; toArray$java_util_function_IntFunction<A>(generator: (p0: number) => A[]): A[]; toArray<A>(generator?: any): any; reduce$java_lang_Object$java_util_function_BinaryOperator(identity: T, accumulator: (p1: T, p2: T) => T): T; reduce$java_util_function_BinaryOperator(accumulator: (p1: T, p2: T) => T): java.util.Optional<T>; collect$java_util_stream_Collector<R, A>(collector: java.util.stream.Collector<any, A, R>): R; min(comparator: java.util.Comparator<any>): java.util.Optional<T>; max(comparator: java.util.Comparator<any>): java.util.Optional<T>; count(): number; anyMatch(predicate: (p1: any) => boolean): boolean; allMatch(predicate: (p1: any) => boolean): boolean; noneMatch(predicate: (p1: any) => boolean): boolean; findFirst(): java.util.Optional<T>; findAny(): java.util.Optional<T>; iterator(): java.util.Iterator<T>; isParallel(): boolean; sequential(): java.util.stream.Stream<T>; parallel(): java.util.stream.Stream<T>; unordered(): java.util.stream.Stream<T>; onClose(closeHandler: () => void): java.util.stream.Stream<T>; close(): void; mapToInt(mapper: () => any): java.util.stream.IntStream; mapToLong(mapper: () => any): java.util.stream.LongStream; mapToDouble(mapper: () => any): java.util.stream.DoubleStream; flatMapToInt(mapper: (p1: any) => any): java.util.stream.IntStream; flatMapToLong(mapper: (p1: any) => any): java.util.stream.LongStream; flatMapToDouble(mapper: (p1: any) => any): java.util.stream.DoubleStream; spliterator(): java.util.Spliterator<T>; reduce$java_lang_Object$java_util_function_BiFunction$java_util_function_BinaryOperator(identity: U, accumulator: (p1: U, p2: any) => U, combiner: (p1: U, p2: U) => U): U; reduce(identity?: any, accumulator?: any, combiner?: any): any; collect$java_util_function_Supplier$java_util_function_BiConsumer$java_util_function_BiConsumer<R>(supplier: () => R, accumulator: (p1: R, p2: any) => void, combiner: (p1: R, p2: R) => void): R; collect<R>(supplier?: any, accumulator?: any, combiner?: any): any; } } export declare namespace javaemul.internal.stream { class CountingPredicate<T> { countDown: number; constructor(n: number); /** * * @param {*} t * @return {boolean} */ test(t: T): boolean; } } export declare namespace javaemul.internal.stream { abstract class TransientStreamRow implements javaemul.internal.stream.StreamRow { next: javaemul.internal.stream.StreamRow; chain(next: javaemul.internal.stream.StreamRow): void; abstract item(a?: any): any; abstract end(): any; constructor(); } } export declare namespace javaemul.internal.stream { class VoidRunnable { static dryRun: VoidRunnable; static dryRun_$LI$(): VoidRunnable; run(): void; constructor(); } } export declare namespace javaemul.internal { /** * Provides an interface for simple JavaScript idioms that can not be expressed in Java. * @class */ class JsUtils { static getInfinity(): number; static isUndefined(value: any): boolean; static unsafeCastToString(string: any): string; static setPropertySafe(map: any, key: string, value: any): void; static getIntProperty(map: any, key: string): number; static setIntProperty(map: any, key: string, value: number): void; static typeOf(o: any): string; } } export declare namespace javaemul.internal { /** * A helper class for long comparison. * @class */ class LongCompareHolder { static getLongComparator(): any; } } export declare namespace javaemul.internal.annotations { } export declare namespace javaemul.internal.annotations { } export declare namespace javaemul.internal.annotations { } export declare namespace javaemul.internal.annotations { } export declare namespace javaemul.internal.annotations { } export declare namespace javaemul.internal.annotations { } export declare namespace javaemul.internal { class ObjectHelper { static clone(obj: any): any; } } export declare namespace javaemul.internal { /** * Wraps a native <code>char</code> as an object. * * TODO(jat): many of the classification methods implemented here are not * correct in that they only handle ASCII characters, and many other methods are * not currently implemented. I think the proper approach is to introduce * a * deferred binding parameter which substitutes an implementation using a * fully-correct Unicode character database, at the expense of additional data * being downloaded. That way developers that need the functionality can get it * without those who don't need it paying for it. * * <pre> * The following methods are still not implemented -- most would require Unicode * character db to be useful: * - digit / is* / to*(int codePoint) * - isDefined(char) * - isIdentifierIgnorable(char) * - isJavaIdentifierPart(char) * - isJavaIdentifierStart(char) * - isJavaLetter(char) -- deprecated, so probably not * - isJavaLetterOrDigit(char) -- deprecated, so probably not * - isISOControl(char) * - isMirrored(char) * - isSpaceChar(char) * - isTitleCase(char) * - isUnicodeIdentifierPart(char) * - isUnicodeIdentifierStart(char) * - getDirectionality(*) * - getNumericValue(*) * - getType(*) * - reverseBytes(char) -- any use for this at all in the browser? * - toTitleCase(*) * - all the category constants for classification * * The following do not properly handle characters outside of ASCII: * - digit(char c, int radix) * - isDigit(char c) * - isLetter(char c) * - isLetterOrDigit(char c) * - isLowerCase(char c) * - isUpperCase(char c) * </pre> * @param {string} value * @class */ class CharacterHelper implements java.lang.Comparable<CharacterHelper>, java.io.Serializable { static TYPE: any; static TYPE_$LI$(): any; static MIN_RADIX: number; static MAX_RADIX: number; static MIN_VALUE: string; static MAX_VALUE: string; static MIN_SURROGATE: string; static MAX_SURROGATE: string; static MIN_LOW_SURROGATE: string; static MAX_LOW_SURROGATE: string; static MIN_HIGH_SURROGATE: string; static MAX_HIGH_SURROGATE: string; static MIN_SUPPLEMENTARY_CODE_POINT: number; static MIN_CODE_POINT: number; static MAX_CODE_POINT: number; static SIZE: number; static charCount(codePoint: number): number; static codePointAt$char_A$int(a: string[], index: number): number; static codePointAt$char_A$int$int(a: string[], index: number, limit: number): number; static codePointAt(a?: any, index?: any, limit?: any): any; static codePointAt$java_lang_CharSequence$int(seq: any, index: number): number; static codePointBefore$char_A$int(a: string[], index: number): number; static codePointBefore$char_A$int$int(a: string[], index: number, start: number): number; static codePointBefore(a?: any, index?: any, start?: any): any; static codePointBefore$java_lang_CharSequence$int(cs: any, index: number): number; static codePointCount$char_A$int$int(a: string[], offset: number, count: number): number; static codePointCount(a?: any, offset?: any, count?: any): any; static codePointCount$java_lang_CharSequence$int$int(seq: any, beginIndex: number, endIndex: number): number; static compare(x: string, y: string): number; static digit(c: string, radix: number): number; static getNumericValue(ch: string): number; static forDigit$int$int(digit: number, radix: number): string; static forDigit(digit?: any, radix?: any): any; /** * @skip * * public for shared implementation with Arrays.hashCode * @param {string} c * @return {number} */ static hashCode(c: string): number; static isDigit(c: string): boolean; static digitRegex(): RegExp; static isHighSurrogate(ch: string): boolean; static isLetter(c: string): boolean; static leterRegex(): RegExp; static isLetterOrDigit(c: string): boolean; static leterOrDigitRegex(): RegExp; static isLowerCase(c: string): boolean; static isLowSurrogate(ch: string): boolean; /** * Deprecated - see isWhitespace(char). * @param {string} c * @return {boolean} */ static isSpace(c: string): boolean; static isWhitespace$char(ch: string): boolean; static isWhitespace(ch?: any): any; static isWhitespace$int(codePoint: number): boolean; static whitespaceRegex(): RegExp; static isSupplementaryCodePoint(codePoint: number): boolean; static isSurrogatePair(highSurrogate: string, lowSurrogate: string): boolean; static isUpperCase(c: string): boolean; static isValidCodePoint(codePoint: number): boolean; static offsetByCodePoints$char_A$int$int$int$int(a: string[], start: number, count: number, index: number, codePointOffset: number): number; static offsetByCodePoints(a?: any, start?: any, count?: any, index?: any, codePointOffset?: any): any; static offsetByCodePoints$java_lang_CharSequence$int$int(seq: any, index: number, codePointOffset: number): number; static toChars$int(codePoint: number): string[]; static toChars$int$char_A$int(codePoint: number, dst: string[], dstIndex: number): number; static toChars(codePoint?: any, dst?: any, dstIndex?: any): any; static toCodePoint(highSurrogate: string, lowSurrogate: string): number; static toLowerCase$char(c: string): string; static toLowerCase(c?: any): any; static toLowerCase$int(c: number): number; static toString(x: string): string; static toUpperCase$char(c: string): string; static toUpperCase(c?: any): any; static toUpperCase$int(c: number): string; static valueOf(c: string): string; static codePointAt$java_lang_CharSequence$int$int(cs: any, index: number, limit: number): number; static codePointBefore$java_lang_CharSequence$int$int(cs: any, index: number, start: number): number; static forDigit$int(digit: number): string; /** * Computes the high surrogate character of the UTF16 representation of a * non-BMP code point. See {@link getLowSurrogate}. * * @param {number} codePoint * requested codePoint, required to be >= * MIN_SUPPLEMENTARY_CODE_POINT * @return {string} high surrogate character */ static getHighSurrogate(codePoint: number): string; /** * Computes the low surrogate character of the UTF16 representation of a non-BMP * code point. See {@link getHighSurrogate}. * * @param {number} codePoint * requested codePoint, required to be >= * MIN_SUPPLEMENTARY_CODE_POINT * @return {string} low surrogate character */ static getLowSurrogate(codePoint: number): string; value: string; constructor(value: string); charValue(): string; compareTo$javaemul_internal_CharacterHelper(c: CharacterHelper): number; /** * * @param {javaemul.internal.CharacterHelper} c * @return {number} */ compareTo(c?: any): any; /** * * @param {*} o * @return {boolean} */ equals(o: any): boolean; /** * * @return {number} */ hashCode(): number; /** * * @return {string} */ toString(): string; } namespace CharacterHelper { /** * Use nested class to avoid clinit on outer. * @class */ class BoxedValues { static boxedValues: string[]; static boxedValues_$LI$(): string[]; constructor(); } } } export declare namespace javaemul.internal { /** * Simple Helper class to return Date.now. * @class */ class DateUtil { /** * Returns the numeric value corresponding to the current time - the number * of milliseconds elapsed since 1 January 1970 00:00:00 UTC. * @return {number} */ static now(): number; } } export declare namespace javaemul.internal { /** * Provides utilities to perform operations on Arrays. * @class */ class ArrayHelper { static ARRAY_PROCESS_BATCH_SIZE: number; static clone<T>(array: T[], fromIndex: number, toIndex: number): T[]; /** * Unlike clone, this method returns a copy of the array that is not type * marked. This is only safe for temp arrays as returned array will not do * any type checks. * @param {*} array * @param {number} fromIndex * @param {number} toIndex * @return {Array} */ static unsafeClone(array: any, fromIndex: number, toIndex: number): any[]; static createFrom<T>(array: T[], length: number): T[]; static createNativeArray(length: number): any; static getLength(array: any): number; static setLength(array: any, length: number): void; static removeFrom(array: any, index: number, deleteCount: number): void; static insertTo$java_lang_Object$int$java_lang_Object(array: any, index: number, value: any): void; static insertTo$java_lang_Object$int$java_lang_Object_A(array: any, index: number, values: any[]): void; static insertTo(array?: any, index?: any, values?: any): any; /** * This version of insertTo is specified only for arrays. * Same implementation (and arguments) as "public static void insertTo(Object array, int index, Object[] values)" * @param {*} array * @param {number} index * @param {Array} values */ static insertValuesToArray(array: any, index: number, values: any[]): void; static copy$java_lang_Object$int$java_lang_Object$int$int(array: any, srcOfs: number, dest: any, destOfs: number, len: number): void; static copy$java_lang_Object$int$java_lang_Object$int$int$boolean(src: any, srcOfs: number, dest: any, destOfs: number, len: number, overwrite: boolean): void; static copy(src?: any, srcOfs?: any, dest?: any, destOfs?: any, len?: any, overwrite?: any): any; static applySplice(arrayObject: any, index: number, deleteCount: number, arrayToAdd: any): void; } } export declare namespace javaemul.internal { /** * Math utility methods and constants. * @class */ class MathHelper { static EPSILON: number; static EPSILON_$LI$(): number; static MAX_VALUE: number; static MAX_VALUE_$LI$(): number; static MIN_VALUE: number; static MIN_VALUE_$LI$(): number; static nextDown(x: number): number; static ulp(x: number): number; static nextUp(x: number): number; static E: number; static PI: number; static PI_OVER_180: number; static PI_OVER_180_$LI$(): number; static PI_UNDER_180: number; static PI_UNDER_180_$LI$(): number; static abs$double(x: number): number; static abs$float(x: number): number; static abs$int(x: number): number; static abs(x?: any): any; static abs$long(x: number): number; static acos(x: number): number; static asin(x: number): number; static atan(x: number): number; static atan2(y: number, x: number): number; static cbrt(x: number): number; static ceil(x: number): number; static copySign$double$double(magnitude: number, sign: number): number; static copySign$float$float(magnitude: number, sign: number): number; static copySign(magnitude?: any, sign?: any): any; static cos(x: number): number; static cosh(x: number): number; static exp(x: number): number; static expm1(d: number): number; static floor(x: number): number; static hypot(x: number, y: number): number; static log(x: number): number; static log10(x: number): number; static log1p(x: number): number; static max$double$double(x: number, y: number): number; static max$float$float(x: number, y: number): number; static max$int$int(x: number, y: number): number; static max(x?: any, y?: any): any; static max$long$long(x: number, y: number): number; static min$double$double(x: number, y: number): number; static min$float$float(x: number, y: number): number; static min$int$int(x: number, y: number): number; static min(x?: any, y?: any): any; static min$long$long(x: number, y: number): number; static pow(x: number, exp: number): number; static random(): number; static rint(d: number): number; static round$double(x: number): number; static round$float(x: number): number; static round(x?: any): any; static unsafeCastToInt(d: number): number; static scalb$double$int(d: number, scaleFactor: number): number; static scalb$float$int(f: number, scaleFactor: number): number; static scalb(f?: any, scaleFactor?: any): any; static signum$double(d: number): number; static signum$float(f: number): number; static signum(f?: any): any; static sin(x: number): number; static sinh(x: number): number; static sqrt(x: number): number; static tan(x: number): number; static tanh(x: number): number; static toDegrees(x: number): number; static toRadians(x: number): number; static IEEEremainder(f1: number, f2: number): number; } } export declare namespace javaemul.internal { /** * A utility to provide array stamping. Provided as a separate class to simplify * super-source. * @class */ class ArrayStamper { static stampJavaTypeInfo<T>(array: any, referenceType: T[]): T[]; } } export declare namespace javaemul.internal { /** * Contains logics for calculating hash codes in JavaScript. * @class */ class HashCodes { static sNextHashId: number; static HASH_CODE_PROPERTY: string; static hashCodeForString(s: string): number; static getIdentityHashCode(o: any): number; static getObjectIdentityHashCode(o: any): number; /** * Called from JSNI. Do not change this implementation without updating: * <ul> * <li>{@link com.google.gwt.user.client.rpc.impl.SerializerBase}</li> * </ul> * @return {number} * @private */ static getNextHashId(): number; } } export declare namespace javaemul.internal { /** * Abstract base class for numeric wrapper classes. * @class */ abstract class NumberHelper implements java.io.Serializable { /** * Stores a regular expression object to verify the format of float values. */ static floatRegex: RegExp; /** * @skip * * This function will determine the radix that the string is expressed * in based on the parsing rules defined in the Javadocs for * Integer.decode() and invoke __parseAndValidateInt. * @param {string} s * @param {number} lowerBound * @param {number} upperBound * @return {number} */ static __decodeAndValidateInt(s: string, lowerBound: number, upperBound: number): number; static __decodeNumberString(s: string): NumberHelper.__Decode; /** * @skip * * This function contains common logic for parsing a String as a * floating- point number and validating the range. * @param {string} s * @return {number} */ static __parseAndValidateDouble(s: string): number; /** * @skip * * This function contains common logic for parsing a String in a given * radix and validating the result. * @param {string} s * @param {number} radix * @param {number} lowerBound * @param {number} upperBound * @return {number} */ static __parseAndValidateInt(s: string, radix: number, lowerBound: number, upperBound: number): number; /** * @skip * * This function contains common logic for parsing a String in a given * radix and validating the result. * @param {string} s * @param {number} radix * @return {number} */ static __parseAndValidateLong(s: string, radix: number): number; /** * @skip * * @param {string} str * @return {boolean} {@code true} if the string matches the float format, * {@code false} otherwise * @private */ static __isValidDouble(str: string): boolean; static createFloatRegex(): RegExp; byteValue(): number; abstract doubleValue(): number; abstract floatValue(): number; abstract intValue(): number; abstract longValue(): number; shortValue(): number; constructor(); } namespace NumberHelper { class __Decode { payload: string; radix: number; constructor(radix: number, payload: string); } /** * Use nested class to avoid clinit on outer. * @class */ class __ParseLong { static __static_initialized: boolean; static __static_initialize(): void; /** * The number of digits (excluding minus sign and leading zeros) to * process at a time. The largest value expressible in maxDigits digits * as well as the factor radix^maxDigits must be strictly less than * 2^31. */ static maxDigitsForRadix: number[]; static maxDigitsForRadix_$LI$(): number[]; /** * A table of values radix*maxDigitsForRadix[radix]. */ static maxDigitsRadixPower: number[]; static maxDigitsRadixPower_$LI$(): number[]; /** * The largest number of digits (excluding minus sign and leading zeros) * that can fit into a long for a given radix between 2 and 36, * inclusive. */ static maxLengthForRadix: number[]; static maxLengthForRadix_$LI$(): number[]; /** * A table of floor(MAX_VALUE / maxDigitsRadixPower). */ static maxValueForRadix: number[]; static maxValueForRadix_$LI$(): number[]; static __static_initializer_0(): void; constructor(); } } } export declare namespace test { class Test { static main(args: string[]): void; static assertEquals(o1: any, o2: any): void; static assertTrue(b: boolean): void; static assertFalse(b: boolean): void; static test(): void; static testArrays(): void; static testList(): void; static testSet(): void; static testMap(): void; static testString(): void; static testIO(): void; static key1(): test.MyKey; static key2(): test.MyKey; } class MyKey { data: string; constructor(data: string); toString(): string; /** * * @param {*} obj * @return {boolean} */ equals(obj: any): boolean; /** * * @return {number} */ hashCode(): number; } } export declare namespace java.net { class URL implements java.io.Serializable { jsUrl: Object; constructor(protocol?: any, host?: any, port?: any, file?: any); openStream(): java.io.InputStream; static createObjectURL(obj: any): string; /** * * @param {*} o * @return {boolean} */ equals(o: any): boolean; /** * * @return {number} */ hashCode(): number; getAuthority(): string; getContent(): any; getDefaultPort(): number; getFile(): string; getHost(): string; getPath(): string; getPort(): number; getProtocol(): string; getQuery(): string; getRef(): string; getUserInfo(): string; sameFile(other: URL): boolean; toExternalForm(): string; makeConnection(): XMLHttpRequest; /** * * @return {string} */ toString(): string; } } export declare namespace java.net { class InternalJsURLFactory { static jsURLCtor: Function; static jsURLCtor_$LI$(): Function; static getJsURLConstructor(): Function; static newJsURL(...objects: any[]): URL; constructor(); } } export declare namespace java.net { class InternalJsURLForShell { href: string; protocol: string; username: string; password: string; hostname: string; port: number; pathname: string; search: string; hash: string; constructor(data?: any, url?: any); } } export declare namespace java.util { abstract class EventListenerProxy<T extends java.util.EventListener> implements java.util.EventListener { listener: T; constructor(listener: T); getListener(): T; } } export declare namespace java.util { /** * A set known to be in ascending order. <a * href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/SortedSet.html">[Sun * docs]</a> * * @param <E> element type. * @class */ interface SortedSet<E> extends java.util.Set<E> { comparator(): java.util.Comparator<any>; first(): E; headSet(toElement: E): SortedSet<E>; last(): E; subSet(fromElement: E, toElement: E): SortedSet<E>; tailSet(fromElement: E): SortedSet<E>; } } export declare namespace java.util { /** * Abstract interface for maps. * * @param <K> * key type. * @param <V> * value type. * @class */ interface Map<K, V> { clear(): any; containsKey(key: any): boolean; containsValue(value: any): boolean; entrySet(): java.util.Set<Map.Entry<K, V>>; get(key: any): V; isEmpty(): boolean; keySet(): java.util.Set<K>; put(key: K, value: V): V; putAll(t: Map<any, any>): any; remove(key: any): V; size(): number; values(): java.util.Collection<V>; merge(key: K, value: V, map: (p1: any, p2: any) => any): V; computeIfAbsent(key: K, mappingFunction: (p1: any) => any): V; getOrDefault(key: any, defaultValue: V): V; putIfAbsent(key: K, value: V): V; } namespace Map { /** * Represents an individual map entry. * @class */ interface Entry<K, V> { getKey(): K; getValue(): V; setValue(value: V): V; } namespace Entry { /** * * Returns a comparator that compares {@link Map.Entry} by value using the given * {@link Comparator}. * * * The returned comparator is serializable if the specified comparator is also * serializable. * * @param <K> * the type of the map keys * @param <V> * the type of the map values * @param {*} cmp * the value {@link Comparator} * @return {*} a comparator that compares {@link Map.Entry} by the value. * @since 1.8 */ function comparingByValue<K, V>(cmp: java.util.Comparator<any>): java.util.Comparator<java.util.Map.Entry<K, V>>; } } } export declare namespace java.util { /** * A factory to create JavaScript Map instances. * @class */ class InternalJsMapFactory { static jsMapCtor: any; static jsMapCtor_$LI$(): any; static getJsMapConstructor(): any; static newJsMap<V>(): java.util.InternalJsMap<V>; constructor(); } } export declare namespace java.util { /** * Incomplete and naive implementation of the BitSet utility (mainly for * compatibility/compilation purpose). * * @author Renaud Pawlak * @param {number} nbits * @class */ class BitSet implements java.lang.Cloneable, java.io.Serializable { bits: boolean[]; constructor(nbits?: any); static valueOf(longs: number[]): BitSet; flip$int(bitIndex: number): void; flip$int$int(fromIndex: number, toIndex: number): void; flip(fromIndex?: any, toIndex?: any): any; set$int(bitIndex: number): void; set$int$boolean(bitIndex: number, value: boolean): void; set$int$int(fromIndex: number, toIndex: number): void; set$int$int$boolean(fromIndex: number, toIndex: number, value: boolean): void; set(fromIndex?: any, toIndex?: any, value?: any): any; clear$int(bitIndex: number): void; clear$int$int(fromIndex: number, toIndex: number): void; clear(fromIndex?: any, toIndex?: any): any; clear$(): void; get$int(bitIndex: number): boolean; get$int$int(fromIndex: number, toIndex: number): BitSet; get(fromIndex?: any, toIndex?: any): any; length(): number; isEmpty(): boolean; cardinality(): number; and(set: BitSet): void; or(set: BitSet): void; xor(set: BitSet): void; andNot(set: BitSet): void; size(): number; equals(obj: any): boolean; clone(): any; } } export declare namespace java.util { /** * See <a * href="http://docs.oracle.com/javase/7/docs/api/java/util/Objects.html">the * official Java API doc</a> for details. * @class */ class Objects { constructor(); static compare<T>(a: T, b: T, c: java.util.Comparator<any>): number; static deepEquals(a: any, b: any): boolean; static equals(a: any, b: any): boolean; static hashCode(o: any): number; static hash(...values: any[]): number; static isNull(obj: any): boolean; static nonNull(obj: any): boolean; static requireNonNull$java_lang_Object<T>(obj: T): T; static requireNonNull$java_lang_Object$java_lang_String<T>(obj: T, message: string): T; static requireNonNull<T>(obj?: any, message?: any): any; static requireNonNull$java_lang_Object$java_util_function_Supplier<T>(obj: T, messageSupplier: () => string): T; static toString$java_lang_Object(o: any): string; static toString$java_lang_Object$java_lang_String(o: any, nullDefault: string): string; static toString(o?: any, nullDefault?: any): any; } } export declare namespace java.util { /** * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html"> * the official Java API doc</a> for details. * * @param <T> type of the wrapped reference * @class */ class Optional<T> { static empty<T>(): Optional<T>; static of<T>(value: T): Optional<T>; static ofNullable<T>(value: T): Optional<T>; static EMPTY: Optional<any>; static EMPTY_$LI$(): Optional<any>; ref: T; constructor(ref?: any); isPresent(): boolean; get(): T; ifPresent(consumer: (p1: any) => void): void; filter(predicate: (p1: any) => boolean): Optional<T>; map(mapper: (p1: any) => any): Optional; flatMap(mapper: (p1: any) => Optional): Optional; orElse(other: T): T; orElseGet(other: () => any): T; orElseThrow<X extends Error>(exceptionSupplier: () => any): T; /** * * @param {*} obj * @return {boolean} */ equals(obj: any): boolean; /** * * @return {number} */ hashCode(): number; /** * * @return {string} */ toString(): string; } } export declare namespace java.util { /** * Sorted map providing additional query operations and views. * * @param <K> key type. * @param <V> value type. * @class */ interface NavigableMap<K, V> extends java.util.SortedMap<K, V> { ceilingEntry(key: K): java.util.Map.Entry<K, V>; ceilingKey(key: K): K; descendingKeySet(): java.util.NavigableSet<K>; descendingMap(): NavigableMap<K, V>; firstEntry(): java.util.Map.Entry<K, V>; floorEntry(key: K): java.util.Map.Entry<K, V>; floorKey(key: K): K; headMap(toKey?: any, inclusive?: any): any; higherEntry(key: K): java.util.Map.Entry<K, V>; higherKey(key: K): K; lastEntry(): java.util.Map.Entry<K, V>; lowerEntry(key: K): java.util.Map.Entry<K, V>; lowerKey(key: K): K; navigableKeySet(): java.util.NavigableSet<K>; pollFirstEntry(): java.util.Map.Entry<K, V>; pollLastEntry(): java.util.Map.Entry<K, V>; subMap(fromKey?: any, fromInclusive?: any, toKey?: any, toInclusive?: any): any; tailMap(fromKey?: any, inclusive?: any): any; } } export declare namespace java.util { /** * See <a href="https://docs.oracle.com/javase/8/docs/api/java/util/OptionalDouble.html"> * the official Java API doc</a> for details. * @class */ class OptionalDouble { static empty(): OptionalDouble; static of(value: number): OptionalDouble; static EMPTY: OptionalDouble; static EMPTY_$LI$(): OptionalDouble; ref: number; present: boolean; constructor(value?: any); isPresent(): boolean; getAsDouble(): number; ifPresent(consumer: any): void; orElse(other: number): number; orElseGet(other: any): number; orElseThrow<X extends Error>(exceptionSupplier: () => X): number; /** * * @param {*} obj * @return {boolean} */ equals(obj: any): boolean; /** * * @return {number} */ hashCode(): number; /** * * @return {string} */ toString(): string; } } export declare namespace java.util { /** * General-purpose interface for storing collections of objects. <a * href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/Collection.html">[Sun * docs]</a> * * @param <E> element type * @class */ interface Collection<E> extends java.lang.Iterable<E> { add(o: E): boolean; addAll(c: Collection<any>): boolean; clear(): any; contains(o: any): boolean; containsAll(c: Collection<any>): boolean; isEmpty(): boolean; /** * * @return {*} */ iterator(): java.util.Iterator<E>; remove(o: any): boolean; removeAll(c: Collection<any>): boolean; removeIf(filter: (p1: any) => boolean): boolean; retainAll(c: Collection<any>): boolean; size(): number; toArray<T>(a?: any): any; stream(): java.util.stream.Stream<E>; } } export declare namespace java.util { /** * Construct an Observable with zero Observers. * @class */ class Observable { changed: boolean; obs: java.util.Vector<java.util.Observer>; constructor(); /** * Adds an observer to the set of observers for this object, provided that * it is not the same as some observer already in the set. The order in * which notifications will be delivered to multiple observers is not * specified. See the class comment. * * @param {*} o * an observer to be added. * @throws NullPointerException * if the parameter o is null. */ addObserver(o: java.util.Observer): void; /** * Deletes an observer from the set of observers of this object. Passing * <CODE>null</CODE> to this method will have no effect. * * @param {*} o * the observer to be deleted. */ deleteObserver(o: java.util.Observer): void; notifyObservers$(): void; notifyObservers$java_lang_Object(arg: any): void; /** * If this object has changed, as indicated by the <code>hasChanged</code> * method, then notify all of its observers and then call the * <code>clearChanged</code> method to indicate that this object has no * longer changed. * * Each observer has its <code>update</code> method called with two * arguments: this observable object and the <code>arg</code> argument. * * @param {*} arg * any object. * @see java.util.Observable#clearChanged() * @see java.util.Observable#hasChanged() * @see java.util.Observer#update(java.util.Observable, java.lang.Object) */ notifyObservers(arg?: any): any; /** * Clears the observer list so that this object no longer has any observers. */ deleteObservers(): void; /** * Marks this <tt>Observable</tt> object as having been changed; the * <tt>hasChanged</tt> method will now return <tt>true</tt>. */ setChanged(): void; /** * Indicates that this object has no longer changed, or that it has already * notified all of its observers of its most recent change, so that the * <tt>hasChanged</tt> method will now return <tt>false</tt>. This method is * called automatically by the <code>notifyObservers</code> methods. * * @see java.util.Observable#notifyObservers() * @see java.util.Observable#notifyObservers(java.lang.Object) */ clearChanged(): void; /** * Tests if this object has changed. * * @return {boolean} <code>true</code> if and only if the <code>setChanged</code> * method has been called more recently than the * <code>clearChanged</code> method on this object; * <code>false</code> otherwise. * @see java.util.Observable#clearChanged() * @see java.util.Observable#setChanged() */ hasChanged(): boolean; /** * Returns the number of observers of this <tt>Observable</tt> object. * * @return {number} the number of observers of this object. */ countObservers(): number; } } export declare namespace java.util { /** * A simple wrapper around JavaScriptObject to provide {@link java.util.Map}-like semantics for any * key type. * * Implementation notes: * * A key's hashCode is the index in backingMap which should contain that key. Since several keys may * have the same hash, each value in hashCodeMap is actually an array containing all entries whose * keys share the same hash. * @param {java.util.AbstractHashMap} host * @class */ class InternalHashCodeMap<K, V> implements java.lang.Iterable<java.util.Map.Entry<K, V>> { forEach(action: (p1: any) => void): void; backingMap: java.util.InternalJsMap<any>; host: java.util.AbstractHashMap<K, V>; __size: number; constructor(host: java.util.AbstractHashMap<K, V>); put(key: K, value: V): V; remove(key: any): V; getEntry(key: any): java.util.Map.Entry<K, V>; findEntryInChain(key: any, chain: java.util.Map.Entry<K, V>[]): java.util.Map.Entry<K, V>; size(): number; /** * * @return {*} */ iterator(): java.util.Iterator<java.util.Map.Entry<K, V>>; getChainOrEmpty(hashCode: number): java.util.Map.Entry<K, V>[]; newEntryChain(): java.util.Map.Entry<K, V>[]; unsafeCastToArray(arr: any): java.util.Map.Entry<K, V>[]; /** * Returns hash code of the key as calculated by {@link AbstractHashMap#getHashCode(Object)} but * also handles null keys as well. * @param {*} key * @return {number} * @private */ hash(key: any): number; } namespace InternalHashCodeMap { class InternalHashCodeMap$0 implements java.util.Iterator<java.util.Map.Entry<any, any>> { __parent: any; forEachRemaining(consumer: (p1: any) => void): void; chains: java.util.InternalJsMap.Iterator<any>; itemIndex: number; chain: java.util.Map.Entry<any, any>[]; lastEntry: java.util.Map.Entry<any, any>; /** * * @return {boolean} */ hasNext(): boolean; /** * * @return {*} */ next(): java.util.Map.Entry<any, any>; /** * */ remove(): void; constructor(__parent: any); } } } export declare namespace java.util { /** * Represents a sequence of objects. <a * href="http://java.sun.com/j2se/1.5.0/docs/api/java/util/List.html">[Sun docs]</a> * * @param <E> element type * @class */ interface List<E> extends java.util.Collection<E> { add(index?: any, element?: any): any; addAll(index?: any, c?: any): any; /** * */ clear(): any; /** * * @param {*} o * @return {boolean} */ contains(o: any): boolean; /** * * @param {*} c * @return {boolean} */ containsAll(c: java.util.Collection<any>): boolean; get(index: number): E; indexOf(o: any): number; /** * * @return {boolean} */ isEmpty(): boolean; /** * * @return {*} */ iterator(): java.util.Iterator<E>; lastIndexOf(o: any): number; listIterator(from?: any): any; remove(index?: any): any; /** * * @param {*} c * @return {boolean} */ removeAll(c: java.util.Collection<any>): boolean; /** * * @param {*} c * @return {boolean} */ retainAll(c: java.util.Collection<any>): boolean; set(index: number, element: E): E; /** * * @return {number} */ size(): number; subList(fromIndex: number, toIndex: number): List<E>; /** * * @param {Array} array * @return {Array} */