#
# 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 {
  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 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 {
  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 {
  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)
}

class ListIterator -> java.util.ListIterator {
  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 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 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 {
  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 {
  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 {
  void forEachRemaining(def)
}

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

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

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

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

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

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

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

class RandomAccess -> java.util.RandomAccess {
}

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

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

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

#### Classes

class AbstractCollection -> java.util.AbstractCollection {
}

class AbstractList -> java.util.AbstractList {
}

class AbstractMap -> java.util.AbstractMap {
}

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

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

class AbstractQueue -> java.util.AbstractQueue {
}

class AbstractSequentialList -> java.util.AbstractSequentialList {
}

class AbstractSet -> java.util.AbstractSet {
}

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

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

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

class Base64 -> 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 Base64.Decoder -> java.util.Base64$Decoder {
  int decode(byte[],byte[])
  byte[] decode(String)
}

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

class BitSet -> 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 Calendar -> 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()
  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 {
  ()
  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 {
  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 {
  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 {
  ()
  (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 {
  Enumeration elements()
  def get(def)
  boolean isEmpty()
  Enumeration keys()
  def put(def,def)
  def remove(def)
  int size()
}

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

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

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

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

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

class GregorianCalendar -> 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 HashMap -> java.util.HashMap {
  ()
  (Map)
  def clone()
}

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

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

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

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

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

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

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

class Locale -> 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 Locale.Builder -> 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 Locale.LanguageRange -> 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 LongSummaryStatistics -> java.util.LongSummaryStatistics {
  ()
  void combine(LongSummaryStatistics)
  double getAverage()
  long getCount()
  long getMax()
  long getMin()
  long getSum()
}

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

class Optional -> 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 OptionalDouble -> 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 OptionalInt -> 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 OptionalLong -> 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 PriorityQueue -> java.util.PriorityQueue {
  ()
  (Comparator)
}

class Random -> java.util.Random {
  ()
  (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 {
  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 Spliterators -> 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 Stack -> java.util.Stack {
  ()
  def push(def)
  def pop()
  def peek()
  boolean empty()
  int search(def)
}

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

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

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

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

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

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

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

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

class EmptyStackException -> java.util.EmptyStackException {
  ()
}

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

class FormatterClosedException -> java.util.FormatterClosedException {
  ()
}

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

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

class IllegalFormatException -> java.util.IllegalFormatException {
}

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

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

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

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

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

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

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

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

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

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

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

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