#
# Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
# or more contributor license agreements. Licensed under the Elastic License
# 2.0 and the Server Side Public License, v 1; you may not use this file except
# in compliance with, at your election, the Elastic License 2.0 or the Server
# Side Public License, v 1.
#

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

#### Interfaces

class java.util.Collection {
  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 org.elasticsearch.painless.api.Augmentation collect(Function)
  def org.elasticsearch.painless.api.Augmentation collect(Collection,Function)
  def org.elasticsearch.painless.api.Augmentation find(Predicate)
  List org.elasticsearch.painless.api.Augmentation findAll(Predicate)
  def org.elasticsearch.painless.api.Augmentation findResult(Function)
  def org.elasticsearch.painless.api.Augmentation findResult(def,Function)
  List org.elasticsearch.painless.api.Augmentation split(Predicate)
}

class 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 java.util.Deque {
  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 java.util.Enumeration {
  boolean hasMoreElements()
  def nextElement()
}

class java.util.EventListener {
}

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

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

class java.util.List {
  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 org.elasticsearch.painless.api.Augmentation getLength()
  void sort(Comparator)
  List subList(int,int)
  Object org.elasticsearch.painless.api.Augmentation getByPath(String)
  Object org.elasticsearch.painless.api.Augmentation getByPath(String, Object)
}

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

class 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()
  Object org.elasticsearch.painless.api.Augmentation getByPath(String)
  Object org.elasticsearch.painless.api.Augmentation getByPath(String, Object)

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

class 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 java.util.NavigableMap {
  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 java.util.NavigableSet {
  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 java.util.Observer {
  void update(Observable,Object)
}

class java.util.PrimitiveIterator {
  void forEachRemaining(def)
}

class java.util.PrimitiveIterator$OfDouble {
  Double next()
  double nextDouble()
}

class java.util.PrimitiveIterator$OfInt {
  Integer next()
  int nextInt()
}

class java.util.PrimitiveIterator$OfLong {
  Long next()
  long nextLong()
}

class 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 java.util.Spliterator$OfPrimitive {
  void forEachRemaining(def)
  boolean tryAdvance(def)
  Spliterator.OfPrimitive trySplit()
}

class java.util.Spliterator$OfDouble {
  Spliterator.OfDouble trySplit()
}

class java.util.Spliterator$OfInt {
  Spliterator.OfInt trySplit()
}

class java.util.Spliterator$OfLong {
  Spliterator.OfLong trySplit()
}

class java.util.Queue {
  def element()
  boolean offer(def)
  def peek()
  def poll()
  def remove()
}

class java.util.RandomAccess {
}

class java.util.Set {
  boolean equals(Object)
  int hashCode()
  boolean remove(def)
}

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

class java.util.SortedSet {
  Comparator comparator()
  def first()
  SortedSet headSet(def)
  def last()
  SortedSet subSet(def,def)
  SortedSet tailSet(def)
}

#### Classes

class java.util.AbstractCollection {
}

class java.util.AbstractList {
}

class java.util.AbstractMap {
}

class java.util.AbstractMap$SimpleEntry {
  (def,def)
  (Map.Entry)
}

class java.util.AbstractMap$SimpleImmutableEntry {
  (def,def)
  (Map.Entry)
}

class java.util.AbstractQueue {
}

class java.util.AbstractSequentialList {
}

class java.util.AbstractSet {
}

class java.util.ArrayDeque {
  ()
  (Collection)
  ArrayDeque clone()
}

class java.util.ArrayList {
  ()
  (Collection)
  def clone()
  void trimToSize()
}

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

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

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

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

class java.util.BitSet {
  ()
  (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 java.util.Calendar {
  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() @nondeterministic
  Calendar getInstance(TimeZone) @nondeterministic
  Calendar getInstance(TimeZone,Locale) @nondeterministic
  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 java.util.Calendar$Builder {
  ()
  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 java.util.Collections {
  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) @nondeterministic
  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 java.util.Currency {
  Set getAvailableCurrencies()
  String getCurrencyCode()
  int getDefaultFractionDigits()
  String getDisplayName()
  String getDisplayName(Locale)
  Currency getInstance(String)
  int getNumericCode()
  String getSymbol()
  String getSymbol(Locale)
}

class java.util.Date {
  () @nondeterministic
  (long)
  boolean after(Date)
  boolean before(Date)
  def clone()
  int compareTo(Date)
  Date from(Instant)
  long getTime()
  void setTime(long)
}

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

class java.util.DoubleSummaryStatistics {
  ()
  void combine(DoubleSummaryStatistics)
  double getAverage()
  long getCount()
  double getMax()
  double getMin()
  double getSum()
}

class java.util.EventListenerProxy {
  EventListener getListener()
}

class java.util.EventObject {
  (Object)
  Object getSource()
}

class java.util.FormattableFlags {
  int ALTERNATE
  int LEFT_JUSTIFY
  int UPPERCASE
}

class java.util.Formatter {
  ()
  (Appendable)
  (Appendable,Locale)
  Formatter format(Locale,String,def[])
  Formatter format(String,def[])
  Locale locale()
  Appendable out()
}

class java.util.GregorianCalendar {
  int AD
  int BC
  ()
  (int,int,int)
  (int,int,int,int,int)
  (int,int,int,int,int,int)
  (TimeZone)
  (TimeZone,Locale)
  GregorianCalendar from(ZonedDateTime)
  Date getGregorianChange()
  boolean isLeapYear(int)
  void setGregorianChange(Date)
  ZonedDateTime toZonedDateTime()
}

class java.util.HashMap {
  ()
  (Map)
  def clone()
}

class java.util.HashSet {
  ()
  (Collection)
  def clone()
}

class java.util.Hashtable {
  ()
  (Map)
  def clone()
}

class java.util.IdentityHashMap {
  ()
  (Map)
  def clone()
}

class java.util.IntSummaryStatistics {
  ()
  void combine(IntSummaryStatistics)
  double getAverage()
  long getCount()
  int getMax()
  int getMin()
  long getSum()
}

class java.util.LinkedHashMap {
  ()
  (Map)
}

class java.util.LinkedHashSet {
  ()
  (Collection)
}

class java.util.LinkedList {
  ()
  (Collection)
  def clone()
}

class java.util.Locale {
  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
  (String)
  (String,String)
  (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 java.util.Locale$Builder {
  ()
  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 java.util.Locale$LanguageRange {
  double MAX_WEIGHT
  double MIN_WEIGHT
  (String)
  (String,double)
  String getRange()
  double getWeight()
  List mapEquivalents(List,Map)
  List parse(String)
  List parse(String,Map)
}

class java.util.LongSummaryStatistics {
  ()
  void combine(LongSummaryStatistics)
  double getAverage()
  long getCount()
  long getMax()
  long getMin()
  long getSum()
}

class java.util.Objects {
  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 java.util.Observable {
  ()
  void addObserver(Observer)
  int countObservers()
  void deleteObserver(Observer)
  void deleteObservers()
  boolean hasChanged()
  void notifyObservers()
  void notifyObservers(Object)
}

class java.util.Optional {
  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 java.util.OptionalDouble {
  OptionalDouble empty()
  double getAsDouble()
  void ifPresent(DoubleConsumer)
  boolean isPresent()
  OptionalDouble of(double)
  double orElse(double)
  double orElseGet(DoubleSupplier)
  double orElseThrow(Supplier)
}

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

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

class java.util.PriorityQueue {
  ()
  (Comparator)
}

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

class java.util.SimpleTimeZone {
  int STANDARD_TIME
  int UTC_TIME
  int WALL_TIME
  (int,String)
  (int,String,int,int,int,int,int,int,int,int)
  (int,String,int,int,int,int,int,int,int,int,int)
  (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 java.util.Spliterators {
  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 java.util.Stack {
  ()
  def push(def)
  def pop()
  def peek()
  boolean empty()
  int search(def)
}

class java.util.StringJoiner {
  (CharSequence)
  (CharSequence,CharSequence,CharSequence)
  StringJoiner add(CharSequence)
  int length()
  StringJoiner merge(StringJoiner)
  StringJoiner setEmptyValue(CharSequence)
}

class java.util.StringTokenizer {
  (String)
  (String,String)
  (String,String,boolean)
  int countTokens()
  boolean hasMoreTokens()
  String nextToken()
  String nextToken(String)
}

class java.util.TimeZone {
  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 java.util.TreeMap {
  ()
  (Comparator)
  def clone()
}

class java.util.TreeSet {
  ()
  (Comparator)
  def clone()
}

class java.util.UUID {
  (long,long)
  int compareTo(UUID)
  int clockSequence()
  UUID fromString(String)
  long getLeastSignificantBits()
  long getMostSignificantBits()
  UUID randomUUID() @nondeterministic
  UUID nameUUIDFromBytes(byte[])
  long node()
  long timestamp()
  int variant()
  int version()
}

class java.util.Vector {
  ()
  (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 java.util.Formatter$BigDecimalLayoutForm {
  Formatter.BigDecimalLayoutForm DECIMAL_FLOAT
  Formatter.BigDecimalLayoutForm SCIENTIFIC
}

class java.util.Locale$Category {
  Locale.Category DISPLAY
  Locale.Category FORMAT
  Locale.Category valueOf(String)
  Locale.Category[] values()
}

class java.util.Locale$FilteringMode {
  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 java.util.ConcurrentModificationException {
  ()
  (String)
}

class java.util.DuplicateFormatFlagsException {
  (String)
  String getFlags()
}

class java.util.EmptyStackException {
  ()
}

class java.util.FormatFlagsConversionMismatchException {
  (String,char)
  char getConversion()
  String getFlags()
}

class java.util.FormatterClosedException {
  ()
}

class java.util.IllegalFormatCodePointException {
  (int)
  int getCodePoint()
}

class java.util.IllegalFormatConversionException {
  char getConversion()
}

class java.util.IllegalFormatException {
}

class java.util.IllegalFormatFlagsException {
  (String)
  String getFlags()
}

class java.util.IllegalFormatPrecisionException {
  (int)
  int getPrecision()
}

class java.util.IllegalFormatWidthException {
  (int)
  int getWidth()
}

class java.util.IllformedLocaleException {
  ()
  (String)
  (String,int)
  int getErrorIndex()
}

class java.util.InputMismatchException {
  ()
  (String)
}

class java.util.MissingFormatArgumentException {
  (String)
  String getFormatSpecifier()
}

class java.util.MissingFormatWidthException {
  (String)
  String getFormatSpecifier()
}

class java.util.MissingResourceException {
  (String,String,String)
  String getClassName()
  String getKey()
}

class java.util.NoSuchElementException {
  ()
  (String)
}

class java.util.TooManyListenersException {
  ()
  (String)
}

class java.util.UnknownFormatConversionException {
  (String)
  String getConversion()
}

class java.util.UnknownFormatFlagsException {
  (String)
  String getFlags()
}
