#
# Licensed to Elasticsearch under one or more contributor
# license agreements. See the NOTICE file distributed with
# this work for additional information regarding copyright
# ownership. Elasticsearch licenses this file to you under
# the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied.  See the License for the
# specific language governing permissions and limitations
# under the License.
#

#
# Painless definition file. This defines the hierarchy of classes,
# what methods and fields they have, etc.
#

#### Interfaces

class Collection -> java.util.Collection extends Iterable {
  boolean add(def)
  boolean addAll(Collection)
  void clear()
  boolean contains(def)
  boolean containsAll(Collection)
  boolean isEmpty()
  boolean removeAll(Collection)
  boolean removeIf(Predicate)
  boolean retainAll(Collection)
  int size()
  Spliterator spliterator()
  Stream stream()
  def[] toArray()
  def[] toArray(def[])

  # some adaptations of groovy methods
  List collect*(Function)
  def collect*(Collection,Function)
  def find*(Predicate)
  List findAll*(Predicate)
  def findResult*(Function)
  def findResult*(def,Function)
  List split*(Predicate)
}

class Comparator -> java.util.Comparator {
  int compare(def,def)
  Comparator comparing(Function)
  Comparator comparing(Function,Comparator)
  Comparator comparingDouble(ToDoubleFunction)
  Comparator comparingInt(ToIntFunction)
  Comparator comparingLong(ToLongFunction)
  boolean equals(Object)
  Comparator naturalOrder()
  Comparator nullsFirst(Comparator)
  Comparator nullsLast(Comparator)
  Comparator reversed()
  Comparator reverseOrder()
  Comparator thenComparing(Comparator)
  Comparator thenComparing(Function,Comparator)
  Comparator thenComparingDouble(ToDoubleFunction)
  Comparator thenComparingInt(ToIntFunction)
  Comparator thenComparingLong(ToLongFunction)
}

class Deque -> java.util.Deque extends Queue,Collection,Iterable {
  void addFirst(def)
  void addLast(def)
  Iterator descendingIterator()
  def getFirst()
  def getLast()
  boolean offerFirst(def)
  boolean offerLast(def)
  def peekFirst()
  def peekLast()
  def pollFirst()
  def pollLast()
  def pop()
  void push(def)
  boolean remove(def)
  def removeFirst()
  boolean removeFirstOccurrence(def)
  def removeLast()
  boolean removeLastOccurrence(def)
}

class Enumeration -> java.util.Enumeration {
  boolean hasMoreElements()
  def nextElement()
}

class EventListener -> java.util.EventListener {
}

class Formattable -> java.util.Formattable {
  void formatTo(Formatter,int,int,int)
}

class Iterator -> java.util.Iterator {
  void forEachRemaining(Consumer)
  boolean hasNext()
  def next()
  void remove()
}

class List -> java.util.List extends Collection,Iterable {
  void add(int,def)
  boolean addAll(int,Collection)
  boolean equals(Object)
  def get(int)
  int hashCode()
  int indexOf(def)
  int lastIndexOf(def)
  ListIterator listIterator()
  ListIterator listIterator(int)
  def remove(int)
  void replaceAll(UnaryOperator)
  def set(int,def)
  int getLength*()
  void sort(Comparator)
  List subList(int,int)
}

class ListIterator -> java.util.ListIterator extends Iterator {
  void add(def)
  boolean hasPrevious()
  int nextIndex()
  int previousIndex()
  void set(def)
}

class Map -> java.util.Map {
  void clear()
  def compute(def,BiFunction)
  def computeIfAbsent(def,Function)
  def computeIfPresent(def,BiFunction)
  boolean containsKey(def)
  boolean containsValue(def)
  Set entrySet()
  boolean equals(Object)
  void forEach(BiConsumer)
  def get(def)
  def getOrDefault(def,def)
  boolean isEmpty()
  Set keySet()
  def merge(def,def,BiFunction)
  def put(def,def)
  void putAll(Map)
  def putIfAbsent(def,def)
  def remove(def)
  boolean remove(def,def)
  def replace(def,def)
  boolean replace(def,def,def)
  void replaceAll(BiFunction)
  int size()
  Collection values()

  # some adaptations of groovy methods
  List collect*(BiFunction)
  def collect*(Collection,BiFunction)
  int count*(BiPredicate)
  def each*(BiConsumer)
  boolean every*(BiPredicate)
  Map.Entry find*(BiPredicate)
  Map findAll*(BiPredicate)
  def findResult*(BiFunction)
  def findResult*(def,BiFunction)
  List findResults*(BiFunction)
  Map groupBy*(BiFunction)
}

class Map.Entry -> java.util.Map$Entry {
  Comparator comparingByKey()
  Comparator comparingByKey(Comparator)
  Comparator comparingByValue()
  Comparator comparingByValue(Comparator)
  boolean equals(Object)
  def getKey()
  def getValue()
  int hashCode()
  def setValue(def)
}

class NavigableMap -> java.util.NavigableMap extends SortedMap,Map {
  Map.Entry ceilingEntry(def)
  def ceilingKey(def)
  NavigableSet descendingKeySet()
  NavigableMap descendingMap()
  Map.Entry firstEntry()
  Map.Entry floorEntry(def)
  def floorKey(def)
  NavigableMap headMap(def,boolean)
  Map.Entry higherEntry(def)
  def higherKey(def)
  Map.Entry lastEntry()
  Map.Entry lowerEntry(def)
  NavigableSet navigableKeySet()
  Map.Entry pollFirstEntry()
  Map.Entry pollLastEntry()
  NavigableMap subMap(def,boolean,def,boolean)
  NavigableMap tailMap(def,boolean)
}

class NavigableSet -> java.util.NavigableSet extends SortedSet,Set,Collection,Iterable {
  def ceiling(def)
  Iterator descendingIterator()
  NavigableSet descendingSet()
  def floor(def)
  NavigableSet headSet(def,boolean)
  def higher(def)
  def lower(def)
  def pollFirst()
  def pollLast()
  NavigableSet subSet(def,boolean,def,boolean)
  NavigableSet tailSet(def,boolean)
}

class Observer -> java.util.Observer {
  void update(Observable,Object)
}

class PrimitiveIterator -> java.util.PrimitiveIterator extends Iterator {
  void forEachRemaining(def)
}

class PrimitiveIterator.OfDouble -> java.util.PrimitiveIterator$OfDouble extends PrimitiveIterator,Iterator {
  Double next()
  double nextDouble()
}

class PrimitiveIterator.OfInt -> java.util.PrimitiveIterator$OfInt extends PrimitiveIterator,Iterator {
  Integer next()
  int nextInt()
}

class PrimitiveIterator.OfLong -> java.util.PrimitiveIterator$OfLong extends PrimitiveIterator,Iterator {
  Long next()
  long nextLong()
}

class Spliterator -> java.util.Spliterator {
  int CONCURRENT
  int DISTINCT
  int IMMUTABLE
  int NONNULL
  int ORDERED
  int SIZED
  int SORTED
  int SUBSIZED
  int characteristics()
  long estimateSize()
  void forEachRemaining(Consumer)
  Comparator getComparator()
  long getExactSizeIfKnown()
  boolean hasCharacteristics(int)
  boolean tryAdvance(Consumer)
  Spliterator trySplit()
}

class Spliterator.OfPrimitive -> java.util.Spliterator$OfPrimitive extends Spliterator {
  void forEachRemaining(def)
  boolean tryAdvance(def)
  Spliterator.OfPrimitive trySplit()
}

class Spliterator.OfDouble -> java.util.Spliterator$OfDouble extends Spliterator.OfPrimitive,Spliterator {
  Spliterator.OfDouble trySplit()
}

class Spliterator.OfInt -> java.util.Spliterator$OfInt extends Spliterator.OfPrimitive,Spliterator {
  Spliterator.OfInt trySplit()
}

class Spliterator.OfLong -> java.util.Spliterator$OfLong extends Spliterator.OfPrimitive,Spliterator {
  Spliterator.OfLong trySplit()
}

class Queue -> java.util.Queue extends Collection,Iterable {
  def element()
  boolean offer(def)
  def peek()
  def poll()
  def remove()
}

class RandomAccess -> java.util.RandomAccess {
}

class Set -> java.util.Set extends Collection,Iterable {
  boolean equals(Object)
  int hashCode()
  boolean remove(def)
}

class SortedMap -> java.util.SortedMap extends Map {
  Comparator comparator()
  def firstKey()
  SortedMap headMap(def)
  def lastKey()
  SortedMap subMap(def,def)
  SortedMap tailMap(def)
}

class SortedSet -> java.util.SortedSet extends Set,Collection,Iterable {
  Comparator comparator()
  def first()
  SortedSet headSet(def)
  def last()
  SortedSet subSet(def,def)
  SortedSet tailSet(def)
}

#### Classes

class AbstractCollection -> java.util.AbstractCollection extends Collection,Iterable,Object {
}

class AbstractList -> java.util.AbstractList extends AbstractCollection,List,Collection,Iterable,Object {
}

class AbstractMap -> java.util.AbstractMap extends Map,Object {
}

class AbstractMap.SimpleEntry -> java.util.AbstractMap$SimpleEntry extends Map.Entry,Object {
  AbstractMap.SimpleEntry <init>(def,def)
  AbstractMap.SimpleEntry <init>(Map.Entry)
}

class AbstractMap.SimpleImmutableEntry -> java.util.AbstractMap$SimpleImmutableEntry extends Map.Entry,Object {
  AbstractMap.SimpleImmutableEntry <init>(def,def)
  AbstractMap.SimpleImmutableEntry <init>(Map.Entry)
}

class AbstractQueue -> java.util.AbstractQueue extends AbstractCollection,Queue,Collection,Iterable,Object {
}

class AbstractSequentialList -> java.util.AbstractSequentialList extends AbstractList,AbstractCollection,List,Collection,Iterable,Object {
}

class AbstractSet -> java.util.AbstractSet extends AbstractCollection,Set,Collection,Iterable,Object {
}

class ArrayDeque -> java.util.ArrayDeque extends AbstractCollection,Deque,Queue,Collection,Iterable,Object {
  ArrayDeque <init>()
  ArrayDeque <init>(Collection)
  ArrayDeque clone()
}

class ArrayList -> java.util.ArrayList extends AbstractList,AbstractCollection,List,RandomAccess,Collection,Iterable,Object {
  ArrayList <init>()
  ArrayList <init>(Collection)
  def clone()
  void trimToSize()
}

class Arrays -> java.util.Arrays extends Object {
  List asList(Object[])
  boolean deepEquals(Object[],Object[])
  int deepHashCode(Object[])
  String deepToString(Object[])
}

class Base64 -> java.util.Base64 extends Object {
  Base64.Decoder getDecoder()
  Base64.Encoder getEncoder()
  Base64.Decoder getMimeDecoder()
  Base64.Encoder getMimeEncoder()
  Base64.Encoder getMimeEncoder(int,byte[])
  Base64.Decoder getUrlDecoder()
  Base64.Encoder getUrlEncoder()
}

class Base64.Decoder -> java.util.Base64$Decoder extends Object {
  int decode(byte[],byte[])
  byte[] decode(String)
}

class Base64.Encoder -> java.util.Base64$Encoder extends Object {
  int encode(byte[],byte[])
  String encodeToString(byte[])
  Base64.Encoder withoutPadding()
}

class BitSet -> java.util.BitSet extends Object {
  BitSet <init>()
  BitSet <init>(int)
  void and(BitSet)
  void andNot(BitSet)
  int cardinality()
  void clear()
  void clear(int)
  void clear(int,int)
  def clone()
  void flip(int)
  void flip(int,int)
  boolean intersects(BitSet)
  boolean isEmpty()
  int length()
  int nextClearBit(int)
  int nextSetBit(int)
  void or(BitSet)
  int previousClearBit(int)
  int previousSetBit(int)
  void set(int)
  void set(int,int)
  void set(int,int,boolean)
  int size()
  byte[] toByteArray()
  long[] toLongArray()
  BitSet valueOf(long[])
  void xor(BitSet)
}

class Calendar -> java.util.Calendar extends Comparable,Object {
  int ALL_STYLES
  int AM
  int AM_PM
  int APRIL
  int AUGUST
  int DATE
  int DAY_OF_MONTH
  int DAY_OF_WEEK
  int DAY_OF_WEEK_IN_MONTH
  int DAY_OF_YEAR
  int DECEMBER
  int DST_OFFSET
  int ERA
  int FEBRUARY
  int FIELD_COUNT
  int FRIDAY
  int HOUR
  int HOUR_OF_DAY
  int JANUARY
  int JULY
  int JUNE
  int LONG
  int LONG_FORMAT
  int LONG_STANDALONE
  int MARCH
  int MAY
  int MILLISECOND
  int MINUTE
  int MONDAY
  int MONTH
  int NARROW_FORMAT
  int NARROW_STANDALONE
  int NOVEMBER
  int OCTOBER
  int PM
  int SATURDAY
  int SECOND
  int SEPTEMBER
  int SHORT
  int SHORT_FORMAT
  int SHORT_STANDALONE
  int SUNDAY
  int THURSDAY
  int TUESDAY
  int UNDECIMBER
  int WEDNESDAY
  int WEEK_OF_MONTH
  int WEEK_OF_YEAR
  int YEAR
  int ZONE_OFFSET
  void add(int,int)
  boolean after(Object)
  boolean before(Object)
  void clear()
  void clear(int)
  def clone()
  int compareTo(Calendar)
  int get(int)
  int getActualMaximum(int)
  int getActualMinimum(int)
  Set getAvailableCalendarTypes()
  Locale[] getAvailableLocales()
  String getCalendarType()
  String getDisplayName(int,int,Locale)
  Map getDisplayNames(int,int,Locale)
  int getFirstDayOfWeek()
  int getGreatestMinimum(int)
  Calendar getInstance()
  Calendar getInstance(TimeZone)
  Calendar getInstance(TimeZone,Locale)
  int getLeastMaximum(int)
  int getMaximum(int)
  int getMinimalDaysInFirstWeek()
  int getMinimum(int)
  Date getTime()
  long getTimeInMillis()
  TimeZone getTimeZone()
  int getWeeksInWeekYear()
  int getWeekYear()
  boolean isLenient()
  boolean isSet(int)
  boolean isWeekDateSupported()
  void roll(int,int)
  void set(int,int)
  void set(int,int,int)
  void set(int,int,int,int,int)
  void set(int,int,int,int,int,int)
  void setFirstDayOfWeek(int)
  void setLenient(boolean)
  void setMinimalDaysInFirstWeek(int)
  void setTime(Date)
  void setTimeInMillis(long)
  void setTimeZone(TimeZone)
  void setWeekDate(int,int,int)
  Instant toInstant()
}

class Calendar.Builder -> java.util.Calendar$Builder extends Object {
  Calendar.Builder <init>()
  Calendar build()
  Calendar.Builder set(int,int)
  Calendar.Builder setCalendarType(String)
  Calendar.Builder setDate(int,int,int)
  Calendar.Builder setFields(int[])
  Calendar.Builder setInstant(long)
  Calendar.Builder setLenient(boolean)
  Calendar.Builder setLocale(Locale)
  Calendar.Builder setTimeOfDay(int,int,int)
  Calendar.Builder setTimeOfDay(int,int,int,int)
  Calendar.Builder setTimeZone(TimeZone)
  Calendar.Builder setWeekDate(int,int,int)
  Calendar.Builder setWeekDefinition(int,int)
}

class Collections -> java.util.Collections extends Object {
  List EMPTY_LIST
  Map EMPTY_MAP
  Set EMPTY_SET
  boolean addAll(Collection,def[])
  Queue asLifoQueue(Deque)
  int binarySearch(List,def)
  int binarySearch(List,def,Comparator)
  void copy(List,List)
  boolean disjoint(Collection,Collection)
  Enumeration emptyEnumeration()
  Iterator emptyIterator()
  List emptyList()
  ListIterator emptyListIterator()
  Map emptyMap()
  NavigableMap emptyNavigableMap()
  NavigableSet emptyNavigableSet()
  Set emptySet()
  SortedMap emptySortedMap()
  SortedSet emptySortedSet()
  Enumeration enumeration(Collection)
  void fill(List,def)
  int frequency(Collection,def)
  int indexOfSubList(List,List)
  int lastIndexOfSubList(List,List)
  ArrayList list(Enumeration)
  def max(Collection)
  def max(Collection,Comparator)
  def min(Collection)
  def min(Collection,Comparator)
  List nCopies(int,def)
  Set newSetFromMap(Map)
  boolean replaceAll(List,def,def)
  void reverse(List)
  Comparator reverseOrder()
  Comparator reverseOrder(Comparator)
  void rotate(List,int)
  void shuffle(List)
  void shuffle(List,Random)
  Set singleton(def)
  List singletonList(def)
  Map singletonMap(def,def)
  void sort(List)
  void sort(List,Comparator)
  void swap(List,int,int)
  Collection unmodifiableCollection(Collection)
  List unmodifiableList(List)
  Map unmodifiableMap(Map)
  NavigableMap unmodifiableNavigableMap(NavigableMap)
  NavigableSet unmodifiableNavigableSet(NavigableSet)
  Set unmodifiableSet(Set)
  SortedMap unmodifiableSortedMap(SortedMap)
  SortedSet unmodifiableSortedSet(SortedSet)
}

class Currency -> java.util.Currency extends Object {
  Set getAvailableCurrencies()
  String getCurrencyCode()
  int getDefaultFractionDigits()
  String getDisplayName()
  String getDisplayName(Locale)
  Currency getInstance(String)
  int getNumericCode()
  String getSymbol()
  String getSymbol(Locale)
}

class Date -> java.util.Date extends Comparable,Object {
  Date <init>()
  Date <init>(long)
  boolean after(Date)
  boolean before(Date)
  def clone()
  int compareTo(Date)
  Date from(Instant)
  long getTime()
  void setTime(long)
}

class Dictionary -> java.util.Dictionary extends Object {
  Enumeration elements()
  def get(def)
  boolean isEmpty()
  Enumeration keys()
  def put(def,def)
  def remove(def)
  int size()
}

class DoubleSummaryStatistics -> java.util.DoubleSummaryStatistics extends DoubleConsumer,Object {
  DoubleSummaryStatistics <init>()
  void combine(DoubleSummaryStatistics)
  double getAverage()
  long getCount()
  double getMax()
  double getMin()
  double getSum()
}

class EventListenerProxy -> java.util.EventListenerProxy extends EventListener,Object {
  EventListener getListener()
}

class EventObject -> java.util.EventObject extends Object {
  EventObject <init>(Object)
  Object getSource()
}

class FormattableFlags -> java.util.FormattableFlags extends Object {
  int ALTERNATE
  int LEFT_JUSTIFY
  int UPPERCASE
}

class Formatter -> java.util.Formatter extends Object {
  Formatter <init>()
  Formatter <init>(Appendable)
  Formatter <init>(Appendable,Locale)
  Formatter format(Locale,String,def[])
  Formatter format(String,def[])
  Locale locale()
  Appendable out()
}

class GregorianCalendar -> java.util.GregorianCalendar extends Calendar,Comparable,Object {
  int AD
  int BC
  GregorianCalendar <init>()
  GregorianCalendar <init>(int,int,int)
  GregorianCalendar <init>(int,int,int,int,int)
  GregorianCalendar <init>(int,int,int,int,int,int)
  GregorianCalendar <init>(TimeZone)
  GregorianCalendar <init>(TimeZone,Locale)
  GregorianCalendar from(ZonedDateTime)
  Date getGregorianChange()
  boolean isLeapYear(int)
  void setGregorianChange(Date)
  ZonedDateTime toZonedDateTime()
}

class HashMap -> java.util.HashMap extends AbstractMap,Map,Object {
  HashMap <init>()
  HashMap <init>(Map)
  def clone()
}

class HashSet -> java.util.HashSet extends AbstractSet,Set,Collection,Iterable,Object {
  HashSet <init>()
  HashSet <init>(Collection)
  def clone()
}

class Hashtable -> java.util.Hashtable extends Dictionary,Map,Object {
  Hashtable <init>()
  Hashtable <init>(Map)
  def clone()
}

class IdentityHashMap -> java.util.IdentityHashMap extends AbstractMap,Map,Object {
  IdentityHashMap <init>()
  IdentityHashMap <init>(Map)
  def clone()
}

class IntSummaryStatistics -> java.util.IntSummaryStatistics extends IntConsumer,Object {
  IntSummaryStatistics <init>()
  void combine(IntSummaryStatistics)
  double getAverage()
  long getCount()
  int getMax()
  int getMin()
  long getSum()
}

class LinkedHashMap -> java.util.LinkedHashMap extends HashMap,AbstractMap,Map,Object {
  LinkedHashMap <init>()
  LinkedHashMap <init>(Map)
}

class LinkedHashSet -> java.util.LinkedHashSet extends HashSet,AbstractSet,Set,AbstractCollection,Collection,Iterable,Object {
  LinkedHashSet <init>()
  LinkedHashSet <init>(Collection)
}

class LinkedList -> java.util.LinkedList extends AbstractSequentialList,AbstractList,List,Deque,Queue,AbstractCollection,Collection,Iterable,Object {
  LinkedList <init>()
  LinkedList <init>(Collection)
  def clone()
}

class Locale -> java.util.Locale extends Object {
  Locale CANADA
  Locale CANADA_FRENCH
  Locale CHINA
  Locale CHINESE
  Locale ENGLISH
  Locale FRANCE
  Locale FRENCH
  Locale GERMAN
  Locale GERMANY
  Locale ITALIAN
  Locale ITALY
  Locale JAPAN
  Locale JAPANESE
  Locale KOREA
  Locale KOREAN
  Locale PRC
  char PRIVATE_USE_EXTENSION
  Locale ROOT
  Locale SIMPLIFIED_CHINESE
  Locale TAIWAN
  Locale TRADITIONAL_CHINESE
  Locale UK
  char UNICODE_LOCALE_EXTENSION
  Locale US
  Locale <init>(String)
  Locale <init>(String,String)
  Locale <init>(String,String,String)
  def clone()
  List filter(List,Collection)
  List filterTags(List,Collection)
  Locale forLanguageTag(String)
  Locale[] getAvailableLocales()
  String getCountry()
  Locale getDefault()
  Locale getDefault(Locale.Category)
  String getDisplayCountry()
  String getDisplayCountry(Locale)
  String getDisplayLanguage()
  String getDisplayLanguage(Locale)
  String getDisplayName()
  String getDisplayName(Locale)
  String getDisplayScript()
  String getDisplayScript(Locale)
  String getDisplayVariant()
  String getDisplayVariant(Locale)
  String getExtension(char)
  Set getExtensionKeys()
  String getISO3Country()
  String getISO3Language()
  String[] getISOCountries()
  String[] getISOLanguages()
  String getLanguage()
  String getScript()
  Set getUnicodeLocaleAttributes()
  Set getUnicodeLocaleKeys()
  String getUnicodeLocaleType(String)
  String getVariant()
  boolean hasExtensions()
  Locale lookup(List,Collection)
  String lookupTag(List,Collection)
  Locale stripExtensions()
  String toLanguageTag()
}

class Locale.Builder -> java.util.Locale$Builder extends Object {
  Locale.Builder <init>()
  Locale.Builder addUnicodeLocaleAttribute(String)
  Locale build()
  Locale.Builder clear()
  Locale.Builder clearExtensions()
  Locale.Builder removeUnicodeLocaleAttribute(String)
  Locale.Builder setExtension(char,String)
  Locale.Builder setLanguage(String)
  Locale.Builder setLanguageTag(String)
  Locale.Builder setLocale(Locale)
  Locale.Builder setRegion(String)
  Locale.Builder setScript(String)
  Locale.Builder setUnicodeLocaleKeyword(String,String)
  Locale.Builder setVariant(String)
}

class Locale.LanguageRange -> java.util.Locale$LanguageRange extends Object {
  double MAX_WEIGHT
  double MIN_WEIGHT
  Locale.LanguageRange <init>(String)
  Locale.LanguageRange <init>(String,double)
  String getRange()
  double getWeight()
  List mapEquivalents(List,Map)
  List parse(String)
  List parse(String,Map)
}

class LongSummaryStatistics -> java.util.LongSummaryStatistics extends LongConsumer,Object {
  LongSummaryStatistics <init>()
  void combine(LongSummaryStatistics)
  double getAverage()
  long getCount()
  long getMax()
  long getMin()
  long getSum()
}

class Objects -> java.util.Objects extends Object {
  int compare(def,def,Comparator)
  boolean deepEquals(Object,Object)
  boolean equals(Object,Object)
  int hash(Object[])
  int hashCode(Object)
  boolean isNull(Object)
  boolean nonNull(Object)
  def requireNonNull(def)
  def requireNonNull(def,String)
  String toString(Object)
  String toString(Object,String)
}

class Observable -> java.util.Observable extends Object {
  Observable <init>()
  void addObserver(Observer)
  int countObservers()
  void deleteObserver(Observer)
  void deleteObservers()
  boolean hasChanged()
  void notifyObservers()
  void notifyObservers(Object)
}

class Optional -> java.util.Optional extends Object {
  Optional empty()
  Optional filter(Predicate)
  Optional flatMap(Function)
  def get()
  void ifPresent(Consumer)
  boolean isPresent()
  Optional map(Function)
  Optional of(def)
  Optional ofNullable(def)
  def orElse(def)
  def orElseGet(Supplier)
  def orElseThrow(Supplier)
}

class OptionalDouble -> java.util.OptionalDouble extends Object {
  OptionalDouble empty()
  double getAsDouble()
  void ifPresent(DoubleConsumer)
  boolean isPresent()
  OptionalDouble of(double)
  double orElse(double)
  double orElseGet(DoubleSupplier)
  double orElseThrow(Supplier)
}

class OptionalInt -> java.util.OptionalInt extends Object {
  OptionalInt empty()
  int getAsInt()
  void ifPresent(IntConsumer)
  boolean isPresent()
  OptionalInt of(int)
  int orElse(int)
  int orElseGet(IntSupplier)
  int orElseThrow(Supplier)
}

class OptionalLong -> java.util.OptionalLong extends Object {
  OptionalLong empty()
  long getAsLong()
  void ifPresent(LongConsumer)
  boolean isPresent()
  OptionalLong of(long)
  long orElse(long)
  long orElseGet(LongSupplier)
  long orElseThrow(Supplier)
}

class PriorityQueue -> java.util.PriorityQueue extends AbstractQueue,Queue,AbstractCollection,Collection,Iterable,Object {
  PriorityQueue <init>()
  PriorityQueue <init>(Comparator)
}

class Random -> java.util.Random extends Object {
  Random <init>()
  Random <init>(long)
  DoubleStream doubles(long)
  DoubleStream doubles(long,double,double)
  IntStream ints(long)
  IntStream ints(long,int,int)
  LongStream longs(long)
  LongStream longs(long,long,long)
  boolean nextBoolean()
  void nextBytes(byte[])
  double nextDouble()
  float nextFloat()
  double nextGaussian()
  int nextInt()
  int nextInt(int)
  long nextLong()
  void setSeed(long)
}

class SimpleTimeZone -> java.util.SimpleTimeZone extends TimeZone,Object {
  int STANDARD_TIME
  int UTC_TIME
  int WALL_TIME
  SimpleTimeZone <init>(int,String)
  SimpleTimeZone <init>(int,String,int,int,int,int,int,int,int,int)
  SimpleTimeZone <init>(int,String,int,int,int,int,int,int,int,int,int)
  SimpleTimeZone <init>(int,String,int,int,int,int,int,int,int,int,int,int,int)
  int getDSTSavings()
  void setDSTSavings(int)
  void setEndRule(int,int,int)
  void setEndRule(int,int,int,int)
  void setEndRule(int,int,int,int,boolean)
  void setStartRule(int,int,int)
  void setStartRule(int,int,int,int)
  void setStartRule(int,int,int,int,boolean)
  void setStartYear(int)
}

class Spliterators -> java.util.Spliterators extends Object {
  Spliterator.OfDouble emptyDoubleSpliterator()
  Spliterator.OfInt emptyIntSpliterator()
  Spliterator.OfLong emptyLongSpliterator()
  Spliterator emptySpliterator()
  Iterator iterator(Spliterator)
  Spliterator spliterator(Collection,int)
  Spliterator spliterator(Iterator,long,int)
  Spliterator spliteratorUnknownSize(Iterator,int)
}

class Stack -> java.util.Stack extends Vector,AbstractList,List,AbstractCollection,Collection,Iterable,RandomAccess,Object {
  Stack <init>()
  def push(def)
  def pop()
  def peek()
  boolean empty()
  int search(def)
}

class StringJoiner -> java.util.StringJoiner extends Object {
  StringJoiner <init>(CharSequence)
  StringJoiner <init>(CharSequence,CharSequence,CharSequence)
  StringJoiner add(CharSequence)
  int length()
  StringJoiner merge(StringJoiner)
  StringJoiner setEmptyValue(CharSequence)
}

class StringTokenizer -> java.util.StringTokenizer extends Enumeration,Object {
  StringTokenizer <init>(String)
  StringTokenizer <init>(String,String)
  StringTokenizer <init>(String,String,boolean)
  int countTokens()
  boolean hasMoreTokens()
  String nextToken()
  String nextToken(String)
}

class TimeZone -> java.util.TimeZone extends Object {
  int LONG
  int SHORT
  def clone()
  String[] getAvailableIDs()
  String[] getAvailableIDs(int)
  TimeZone getDefault()
  String getDisplayName()
  String getDisplayName(boolean,int)
  String getDisplayName(boolean,int,Locale)
  String getDisplayName(Locale)
  int getDSTSavings()
  String getID()
  int getOffset(int,int,int,int,int,int)
  int getOffset(long)
  int getRawOffset()
  TimeZone getTimeZone(String)
  boolean hasSameRules(TimeZone)
  boolean inDaylightTime(Date)
  boolean observesDaylightTime()
  void setRawOffset(int)
  ZoneId toZoneId()
  boolean useDaylightTime()
}

class TreeMap -> java.util.TreeMap extends AbstractMap,NavigableMap,SortedMap,Map,Object {
  TreeMap <init>()
  TreeMap <init>(Comparator)
  def clone()
}

class TreeSet -> java.util.TreeSet extends AbstractSet,NavigableSet,SortedSet,Set,AbstractCollection,Collection,Iterable,Object {
  TreeSet <init>()
  TreeSet <init>(Comparator)
  def clone()
}

class UUID -> java.util.UUID extends Comparable,Object {
  UUID <init>(long,long)
  int compareTo(UUID)
  int clockSequence()
  UUID fromString(String)
  long getLeastSignificantBits()
  long getMostSignificantBits()
  UUID nameUUIDFromBytes(byte[])
  long node()
  long timestamp()
  int variant()
  int version()
}

class Vector -> java.util.Vector extends AbstractList,List,AbstractCollection,Collection,Iterable,RandomAccess,Object {
  Vector <init>()
  Vector <init>(Collection)
  void addElement(def)
  void copyInto(Object[])
  def elementAt(int)
  Enumeration elements()
  def firstElement()
  void insertElementAt(def,int)
  def lastElement()
  int lastIndexOf(def,int)
  void removeAllElements()
  boolean removeElement(def)
  void removeElementAt(int)
  void setElementAt(def,int)
  def clone()
}

#### Enums

class Formatter.BigDecimalLayoutForm -> java.util.Formatter$BigDecimalLayoutForm extends Enum,Comparable,Object {
  Formatter.BigDecimalLayoutForm DECIMAL_FLOAT
  Formatter.BigDecimalLayoutForm SCIENTIFIC
}

class Locale.Category -> java.util.Locale$Category extends Enum,Comparable,Object {
  Locale.Category DISPLAY
  Locale.Category FORMAT
  Locale.Category valueOf(String)
  Locale.Category[] values()
}

class Locale.FilteringMode -> java.util.Locale$FilteringMode extends Enum,Comparable,Object {
  Locale.FilteringMode AUTOSELECT_FILTERING
  Locale.FilteringMode EXTENDED_FILTERING
  Locale.FilteringMode IGNORE_EXTENDED_RANGES
  Locale.FilteringMode MAP_EXTENDED_RANGES
  Locale.FilteringMode REJECT_EXTENDED_RANGES
  Locale.FilteringMode valueOf(String)
  Locale.FilteringMode[] values()
}

#### Exceptions

class ConcurrentModificationException -> java.util.ConcurrentModificationException extends RuntimeException,Exception,Object {
  ConcurrentModificationException <init>()
  ConcurrentModificationException <init>(String)
}

class DuplicateFormatFlagsException -> java.util.DuplicateFormatFlagsException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  DuplicateFormatFlagsException <init>(String)
  String getFlags()
}

class EmptyStackException -> java.util.EmptyStackException extends RuntimeException,Exception,Object {
  EmptyStackException <init>()
}

class FormatFlagsConversionMismatchException -> java.util.FormatFlagsConversionMismatchException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  FormatFlagsConversionMismatchException <init>(String,char)
  char getConversion()
  String getFlags()
}

class FormatterClosedException -> java.util.FormatterClosedException extends IllegalStateException,RuntimeException,Exception,Object {
  FormatterClosedException <init>()
}

class IllegalFormatCodePointException -> java.util.IllegalFormatCodePointException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  IllegalFormatCodePointException <init>(int)
  int getCodePoint()
}

class IllegalFormatConversionException -> java.util.IllegalFormatConversionException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  char getConversion()
}

class IllegalFormatException -> java.util.IllegalFormatException extends IllegalArgumentException,RuntimeException,Exception,Object {
}

class IllegalFormatFlagsException -> java.util.IllegalFormatFlagsException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  IllegalFormatFlagsException <init>(String)
  String getFlags()
}

class IllegalFormatPrecisionException -> java.util.IllegalFormatPrecisionException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  IllegalFormatPrecisionException <init>(int)
  int getPrecision()
}

class IllegalFormatWidthException -> java.util.IllegalFormatWidthException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  IllegalFormatWidthException <init>(int)
  int getWidth()
}

class IllformedLocaleException -> java.util.IllformedLocaleException extends RuntimeException,Exception,Object {
  IllformedLocaleException <init>()
  IllformedLocaleException <init>(String)
  IllformedLocaleException <init>(String,int)
  int getErrorIndex()
}

class InputMismatchException -> java.util.InputMismatchException extends NoSuchElementException,RuntimeException,Exception,Object {
  InputMismatchException <init>()
  InputMismatchException <init>(String)
}

class MissingFormatArgumentException -> java.util.MissingFormatArgumentException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  MissingFormatArgumentException <init>(String)
  String getFormatSpecifier()
}

class MissingFormatWidthException -> java.util.MissingFormatWidthException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  MissingFormatWidthException <init>(String)
  String getFormatSpecifier()
}

class MissingResourceException -> java.util.MissingResourceException extends RuntimeException,Exception,Object {
  MissingResourceException <init>(String,String,String)
  String getClassName()
  String getKey()
}

class NoSuchElementException -> java.util.NoSuchElementException extends RuntimeException,Exception,Object {
  NoSuchElementException <init>()
  NoSuchElementException <init>(String)
}

class TooManyListenersException -> java.util.TooManyListenersException extends Exception,Object {
  TooManyListenersException <init>()
  TooManyListenersException <init>(String)
}

class UnknownFormatConversionException -> java.util.UnknownFormatConversionException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  UnknownFormatConversionException <init>(String)
  String getConversion()
}

class UnknownFormatFlagsException -> java.util.UnknownFormatFlagsException extends IllegalFormatException,IllegalArgumentException,RuntimeException,Exception,Object {
  UnknownFormatFlagsException <init>(String)
  String getFlags()
}
