declare global {
    namespace java {
        namespace util {
            class Date {
                constructor()
                constructor(time: long)
                getTime(): long
                setTime(time: long): void
            }

            interface Iterator<T> {
                hasNext(): boolean
                next(): T
                remove(): void
                forEachRemaining(action: (item: T) => void): void
            }
            interface Collection<T> extends Iterable<T> {
                add(e: T): boolean
                addAll(c: java.util.Collection<T>): boolean
                clear(): void
                contains(o: T): boolean
                containsAll(c: java.util.Collection<T>): boolean
                equals(o: java.lang.Object): boolean
                isEmpty(): boolean
                iterator(): java.util.Iterator<T>
                remove(o: java.lang.Object): boolean
                removeAll(c: java.util.Collection<T>): boolean
                retainAll(c: java.util.Collection<T>): boolean
                size(): number
                parallelStream(): java.util.stream.Stream<T>
                stream(): java.util.stream.Stream<T>
                toArray(): T[]
            }

            interface Set<T> extends Collection<T> {}

            interface List<T> extends Collection<T> {
                add(index: number, element: T): void
                add(element: T): boolean
                get(index: number): T
                set(index: number, element: T): T
                remove(index: number): T
                indexOf(o: T): number
                lastIndexOf(o: T): number
                subList(fromIndex: number, toIndex: number): java.util.List<T>
            }

            class ArrayList<T> implements List<T> {
                constructor()
                constructor(initialCapacity: number)
                size(): number
                isEmpty(): boolean
                contains(o: T): boolean
                containsAll(c: java.util.Collection<T>): boolean
                equals(o: java.lang.Object): boolean
                add(e: T): boolean
                add(index: number, element: T): void
                addAll(c: java.util.Collection<T>): boolean
                get(index: number): T
                set(index: number, element: T): T
                remove(o: java.lang.Object): boolean
                remove(index: number): T
                removeAll(c: java.util.Collection<T>): boolean
                retainAll(c: java.util.Collection<T>): boolean
                indexOf(o: T): number
                lastIndexOf(o: T): number
                subList(fromIndex: number, toIndex: number): java.util.List<T>
                clear(): void
                iterator(): java.util.Iterator<T>
                parallelStream(): java.util.stream.Stream<T>
                stream(): java.util.stream.Stream<T>
                toArray(): T[]
                [Symbol.iterator](): IterableIterator<T>
            }

            interface Map<K, V> {
                size(): number
                isEmpty(): boolean
                containsKey(key: K): boolean
                containsValue(value: V): boolean
                getOrDefault(key: K, defaultValue: V): V
                get(key: K): V | undefined
                put(key: K, value: V): V | undefined
                putAll(m: java.util.Map<K, V>): void
                putIfAbsent(key: K, value: V): V | undefined
                remove(key: K): V | undefined
                remove(key: K, value: V): boolean
                clear(): void
                forEach(callback: (key: K, value: V) => void): void
                replace(key: K, value: V): V | undefined
                replace(key: K, oldValue: V, newValue: V): boolean
                replaceAll(mappingFunction: (key: K, value: V) => V): void
                keySet(): java.util.Set<K>
                values(): java.util.Collection<V>
                entrySet(): java.util.Set<java.util.Map.Entry<K, V>>
            }

            namespace Map {
                interface Entry<K, V> {
                    getKey(): K
                    getValue(): V
                    setValue(value: V): V
                }
            }

            class AbstractMap<K, V> implements Map<K, V> {
                constructor()
                size(): number
                isEmpty(): boolean
                containsKey(key: K): boolean
                containsValue(value: V): boolean
                getOrDefault(key: K, defaultValue: V): V
                get(key: K): V | undefined
                put(key: K, value: V): V | undefined
                putAll(m: java.util.Map<K, V>): void
                putIfAbsent(key: K, value: V): V | undefined
                remove(key: K): V | undefined
                remove(key: K, value: V): boolean
                clear(): void
                forEach(callback: (key: K, value: V) => void): void
                replace(key: K, value: V): V | undefined
                replace(key: K, oldValue: V, newValue: V): boolean
                replaceAll(mappingFunction: (key: K, value: V) => V): void
                keySet(): java.util.Set<K>
                values(): java.util.Collection<V>
                entrySet(): java.util.Set<java.util.Map.Entry<K, V>>
            }

            class HashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Clonable, Serializable {
                constructor()
                size(): number
                isEmpty(): boolean
                containsKey(key: K): boolean
                containsValue(value: V): boolean
                getOrDefault(key: K, defaultValue: V): V
                get(key: K): V | undefined
                put(key: K, value: V): V | undefined
                putAll(m: java.util.Map<K, V>): void
                putIfAbsent(key: K, value: V): V | undefined
                remove(key: K): V | undefined
                remove(key: K, value: V): boolean
                clear(): void
                forEach(callback: (key: K, value: V) => void): void
                replace(key: K, value: V): V | undefined
                replace(key: K, oldValue: V, newValue: V): boolean
                replaceAll(mappingFunction: (key: K, value: V) => V): void
                keySet(): java.util.Set<K>
                values(): java.util.Collection<V>
                entrySet(): java.util.Set<java.util.Map.Entry<K, V>>
            }

            class LinkedHashMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Clonable, Serializable {
                constructor()
                size(): number
                isEmpty(): boolean
                containsKey(key: K): boolean
                clear(): void
                containsValue(value: V): boolean
                entrySet(): java.util.Set<java.util.Map.Entry<K, V>>
                forEach(callback: (key: K, value: V) => void): void
                get(key: K): V | undefined
                getOrDefault(key: K, defaultValue: V): V
                put(key: K, value: V): V | undefined
                putAll(m: java.util.Map<K, V>): void
                putIfAbsent(key: K, value: V): V | undefined
                keySet(): java.util.Set<K>
                remove(key: K): V | undefined
                remove(key: K, value: V): boolean
                protected removeEldestEntry(eldest: Map.Entry<K, V>): boolean
                replace(key: K, value: V): V | undefined
                replace(key: K, oldValue: V, newValue: V): boolean
                replaceAll(mappingFunction: (key: K, value: V) => V): void
                values(): java.util.Collection<V>
            }

            class LinkedMap<K, V> extends AbstractMap<K, V> implements Map<K, V>, Clonable, Serializable {
                constructor()
                size(): number
                isEmpty(): boolean
                containsKey(key: K): boolean
                containsValue(value: V): boolean
                getOrDefault(key: K, defaultValue: V): V
                get(key: K): V | undefined
                put(key: K, value: V): V | undefined
                putAll(m: java.util.Map<K, V>): void
                putIfAbsent(key: K, value: V): V | undefined
                remove(key: K): V | undefined
                remove(key: K, value: V): boolean
                clear(): void
                forEach(callback: (key: K, value: V) => void): void
                replace(key: K, value: V): V | undefined
                replace(key: K, oldValue: V, newValue: V): boolean
                replaceAll(mappingFunction: (key: K, value: V) => V): void
                keySet(): java.util.Set<K>
                values(): java.util.Collection<V>
                entrySet(): java.util.Set<java.util.Map.Entry<K, V>>
            }

            class Base64 {
                static getEncoder(): Base64Encoder
                static getDecoder(): Base64Decoder
            }

            interface Base64Encoder {
                encodeToString(data: Uint8Array<ArrayBufferLike>): java.lang.String
            }

            interface Base64Decoder {
                decode(data: java.lang.String): Uint8Array<ArrayBufferLike>
            }

            class Locale extends java.lang.Object {
                constructor(language: java.lang.String)
                constructor(language: java.lang.String, country: java.lang.String)
                getLanguage(): java.lang.String
                getCountry(): java.lang.String
                static getDefault(): java.util.Locale
            }

            type IntStream = java.util.stream.IntStream

            class Properties extends java.util.Hashtable<java.lang.String, java.lang.String> {
                constructor()
                getProperty(key: java.lang.String): java.lang.String | undefined
                getProperty(key: java.lang.String, defaultValue: java.lang.String): java.lang.String
                setProperty(key: java.lang.String, value: java.lang.String): java.lang.String | undefined
                clearProperty(key: java.lang.String): java.lang.String | undefined
            }
            namespace stream {
                interface Stream<T> {
                    iterator(): java.util.Iterator<T>
                    forEach(action: (item: T) => void): void
                    map<R>(mapper: (item: T) => R): Stream<R>
                    filter(predicate: (item: T) => boolean): Stream<T>
                    count(): number
                    findFirst(): T | undefined
                    limit(maxSize: number): Stream<T>
                    skip(n: number): Stream<T>
                    toArray(): T[]
                    collect<R>(collector: (accumulator: R, item: T) => R, initialValue: R): R
                    collect<R>(collector: java.util.stream.Collector<T, R>): R
                }

                interface Collector<T, R> {
                    supplier(): R
                    accumulator(accumulator: R, item: T): void
                    finisher(accumulator: R): R
                }

                interface IntStream {
                    forEach(action: (value: number) => void): void
                    map(mapper: (value: number) => number): IntStream
                    filter(predicate: (value: number) => boolean): IntStream
                    toArray(): number[]
                }
            }
            namespace regex {
                class Pattern {
                    static compile(regex: java.lang.String): Pattern
                    static compile(regex: java.lang.String, flags: number): Pattern
                    static matches(regex: java.lang.String, input: java.lang.String): boolean
                    static quote(s: java.lang.String): java.lang.String
                    asPredicate(): (input: java.lang.String) => boolean
                    flags(): number
                    matcher(input: java.lang.String): Matcher
                    pattern(): java.lang.String
                    split(input: java.lang.String): java.lang.String[]
                    split(input: java.lang.String, limit: number): java.lang.String[]
                    splitAsStream(input: java.lang.String): java.util.stream.Stream<java.lang.String>
                    toString(): java.lang.String
                }
                class Matcher {
                    end(): number
                    end(group: number): number
                    find(): boolean
                    find(start: number): boolean
                    group(): java.lang.String
                    group(group: number): java.lang.String
                    group(name: java.lang.String): java.lang.String
                    groupCount(): number
                    matches(): boolean
                    pattern(): Pattern
                    start(): number
                    start(group: number): number
                    reset(): Matcher
                    reset(input: java.lang.String): Matcher
                    replaceAll(replacement: java.lang.String): java.lang.String
                    replaceFirst(replacement: java.lang.String): java.lang.String
                    static quoteReplacement(s: java.lang.String): java.lang.String
                }
                interface MatchResult {
                    end(): number
                    end(group: number): number
                    group(): java.lang.String
                    group(group: number): java.lang.String
                    groupCount(): number
                    start(): number
                    start(group: number): number
                }
            }
            class Calendar extends java.lang.Object implements java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<java.util.Calendar> {
                static getInstance(): Calendar
                static getInstance(zone: java.util.TimeZone): Calendar
                static getInstance(zone: java.util.TimeZone, aLocale: java.util.Locale): Calendar
                getTime(): java.util.Date
                setTime(date: java.util.Date): void
                get(field: number): number
                set(field: number, value: number): void
                add(field: number, amount: number): void
                roll(field: number, up: boolean): void
                roll(field: number, amount: number): void
                getTimeZone(): java.util.TimeZone
                setTimeZone(value: java.util.TimeZone): void
                getFirstDayOfWeek(): number
                setFirstDayOfWeek(value: number): void
                getMinimalDaysInFirstWeek(): number
                setMinimalDaysInFirstWeek(value: number): void
                getActualMaximum(field: number): number
                getActualMinimum(field: number): number
                getGreatestMinimum(field: number): number
                getLeastMaximum(field: number): number
                isLeapYear(year: number): boolean
                clone(): java.lang.Object
                compareTo(anotherCalendar: java.util.Calendar): number
            }
            class GregorianCalendar extends java.util.Calendar implements java.io.Serializable, java.lang.Cloneable, java.lang.Comparable<java.util.Calendar> {
                constructor()
                constructor(year: number, month: number, dayOfMonth: number)
                constructor(year: number, month: number, dayOfMonth: number, hourOfDay: number, minute: number)
                constructor(year: number, month: number, dayOfMonth: number, hourOfDay: number, minute: number, second: number)
                isLeapYear(year: number): boolean
            }
        }
    }
}
export {}