@enjoys/context-engine 1.4.1 → 1.5.0

package/data/definition/java.json

@@ -1,184 +1,1158 @@
-{
-  "language": "java",
-  "definitions": {
-    "String": {
-      "signature": "public final class String implements Serializable, Comparable<String>, CharSequence",
-      "description": "The String class represents character strings. All string literals in Java programs are implemented as instances of this class. Strings are immutable; their values cannot be changed after they are created.",
-      "type": "class",
-      "module": "java.lang",
-      "members": {
-        "length": { "signature": "public int length()", "description": "Returns the length of this string. The length is equal to the number of Unicode code units in the string.", "type": "method" },
-        "charAt": { "signature": "public char charAt(int index)", "description": "Returns the char value at the specified index. An index ranges from 0 to length() - 1.", "type": "method" },
-        "substring": { "signature": "public String substring(int beginIndex, int endIndex)", "description": "Returns a string that is a substring of this string. The substring begins at beginIndex and extends to the character at endIndex - 1.", "type": "method" },
-        "equals": { "signature": "public boolean equals(Object anObject)", "description": "Compares this string to the specified object. Returns true if the argument is a String object with the same character sequence.", "type": "method" },
-        "equalsIgnoreCase": { "signature": "public boolean equalsIgnoreCase(String anotherString)", "description": "Compares this String to another String, ignoring case considerations.", "type": "method" },
-        "compareTo": { "signature": "public int compareTo(String anotherString)", "description": "Compares two strings lexicographically. Returns a negative integer, zero, or positive integer.", "type": "method" },
-        "contains": { "signature": "public boolean contains(CharSequence s)", "description": "Returns true if this string contains the specified sequence of char values.", "type": "method" },
-        "startsWith": { "signature": "public boolean startsWith(String prefix)", "description": "Tests if this string starts with the specified prefix.", "type": "method" },
-        "endsWith": { "signature": "public boolean endsWith(String suffix)", "description": "Tests if this string ends with the specified suffix.", "type": "method" },
-        "indexOf": { "signature": "public int indexOf(String str)", "description": "Returns the index within this string of the first occurrence of the specified substring. Returns -1 if not found.", "type": "method" },
-        "lastIndexOf": { "signature": "public int lastIndexOf(String str)", "description": "Returns the index within this string of the last occurrence of the specified substring. Returns -1 if not found.", "type": "method" },
-        "replace": { "signature": "public String replace(CharSequence target, CharSequence replacement)", "description": "Replaces each substring of this string that matches the literal target sequence with the specified replacement sequence.", "type": "method" },
-        "replaceAll": { "signature": "public String replaceAll(String regex, String replacement)", "description": "Replaces each substring of this string that matches the given regular expression with the given replacement.", "type": "method" },
-        "split": { "signature": "public String[] split(String regex)", "description": "Splits this string around matches of the given regular expression.", "type": "method" },
-        "trim": { "signature": "public String trim()", "description": "Returns a string whose value is this string, with all leading and trailing space removed, where space is defined as any character whose codepoint is less than or equal to 'U+0020'.", "type": "method" },
-        "strip": { "signature": "public String strip()", "description": "(Java 11+) Returns a string whose value is this string, with all leading and trailing white space removed. Uses Character.isWhitespace() for Unicode-aware trimming.", "type": "method" },
-        "toUpperCase": { "signature": "public String toUpperCase()", "description": "Converts all of the characters in this String to upper case using the rules of the default locale.", "type": "method" },
-        "toLowerCase": { "signature": "public String toLowerCase()", "description": "Converts all of the characters in this String to lower case using the rules of the default locale.", "type": "method" },
-        "isEmpty": { "signature": "public boolean isEmpty()", "description": "Returns true if, and only if, length() is 0.", "type": "method" },
-        "isBlank": { "signature": "public boolean isBlank()", "description": "(Java 11+) Returns true if the string is empty or contains only white space codepoints.", "type": "method" },
-        "toCharArray": { "signature": "public char[] toCharArray()", "description": "Converts this string to a new character array.", "type": "method" },
-        "matches": { "signature": "public boolean matches(String regex)", "description": "Tells whether or not this string matches the given regular expression.", "type": "method" },
-        "format": { "signature": "public static String format(String format, Object... args)", "description": "Returns a formatted string using the specified format string and arguments.", "type": "method" },
-        "join": { "signature": "public static String join(CharSequence delimiter, CharSequence... elements)", "description": "Returns a new String composed of copies of the CharSequence elements joined together with the specified delimiter.", "type": "method" },
-        "valueOf": { "signature": "public static String valueOf(Object obj)", "description": "Returns the string representation of the Object argument. Returns \"null\" if the argument is null.", "type": "method" },
-        "repeat": { "signature": "public String repeat(int count)", "description": "(Java 11+) Returns a string whose value is the concatenation of this string repeated count times.", "type": "method" },
-        "chars": { "signature": "public IntStream chars()", "description": "Returns an IntStream of char values from this sequence. The values are zero-extended to int.", "type": "method" }
-      }
-    },
-    "ArrayList": {
-      "signature": "public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable",
-      "description": "Resizable-array implementation of the List interface. Implements all optional list operations and permits all elements, including null. Provides constant-time positional access and amortized constant-time addition.",
-      "type": "class",
-      "module": "java.util",
-      "members": {
-        "add": { "signature": "public boolean add(E e)", "description": "Appends the specified element to the end of this list. Returns true.", "type": "method" },
-        "get": { "signature": "public E get(int index)", "description": "Returns the element at the specified position in this list. Throws IndexOutOfBoundsException if the index is out of range.", "type": "method" },
-        "set": { "signature": "public E set(int index, E element)", "description": "Replaces the element at the specified position in this list with the specified element. Returns the element previously at the position.", "type": "method" },
-        "remove": { "signature": "public E remove(int index)", "description": "Removes the element at the specified position in this list. Shifts any subsequent elements to the left.", "type": "method" },
-        "size": { "signature": "public int size()", "description": "Returns the number of elements in this list.", "type": "method" },
-        "isEmpty": { "signature": "public boolean isEmpty()", "description": "Returns true if this list contains no elements.", "type": "method" },
-        "contains": { "signature": "public boolean contains(Object o)", "description": "Returns true if this list contains the specified element, as determined by equals().", "type": "method" },
-        "indexOf": { "signature": "public int indexOf(Object o)", "description": "Returns the index of the first occurrence of the specified element in this list, or -1 if not found.", "type": "method" },
-        "clear": { "signature": "public void clear()", "description": "Removes all of the elements from this list. The list will be empty after this call returns.", "type": "method" },
-        "sort": { "signature": "public void sort(Comparator<? super E> c)", "description": "Sorts this list according to the order induced by the specified Comparator. The sort is stable.", "type": "method" },
-        "toArray": { "signature": "public Object[] toArray()", "description": "Returns an array containing all of the elements in this list in proper sequence (from first to last element).", "type": "method" },
-        "subList": { "signature": "public List<E> subList(int fromIndex, int toIndex)", "description": "Returns a view of the portion of this list between the specified fromIndex (inclusive) and toIndex (exclusive).", "type": "method" },
-        "iterator": { "signature": "public Iterator<E> iterator()", "description": "Returns an iterator over the elements in this list in proper sequence.", "type": "method" },
-        "forEach": { "signature": "public void forEach(Consumer<? super E> action)", "description": "Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.", "type": "method" },
-        "stream": { "signature": "public Stream<E> stream()", "description": "Returns a sequential Stream with this collection as its source.", "type": "method" },
-        "addAll": { "signature": "public boolean addAll(Collection<? extends E> c)", "description": "Appends all of the elements in the specified collection to the end of this list, in the order returned by the collection's iterator.", "type": "method" }
-      }
-    },
-    "HashMap": {
-      "signature": "public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable",
-      "description": "Hash table based implementation of the Map interface. This implementation permits null values and the null key. Makes no guarantees as to the order of the map. Provides constant-time performance for basic operations (get and put).",
-      "type": "class",
-      "module": "java.util",
-      "members": {
-        "put": { "signature": "public V put(K key, V value)", "description": "Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced.", "type": "method" },
-        "get": { "signature": "public V get(Object key)", "description": "Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.", "type": "method" },
-        "getOrDefault": { "signature": "public V getOrDefault(Object key, V defaultValue)", "description": "Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.", "type": "method" },
-        "remove": { "signature": "public V remove(Object key)", "description": "Removes the mapping for the specified key from this map if present. Returns the previous value, or null.", "type": "method" },
-        "containsKey": { "signature": "public boolean containsKey(Object key)", "description": "Returns true if this map contains a mapping for the specified key.", "type": "method" },
-        "containsValue": { "signature": "public boolean containsValue(Object value)", "description": "Returns true if this map maps one or more keys to the specified value.", "type": "method" },
-        "keySet": { "signature": "public Set<K> keySet()", "description": "Returns a Set view of the keys contained in this map. The set is backed by the map.", "type": "method" },
-        "values": { "signature": "public Collection<V> values()", "description": "Returns a Collection view of the values contained in this map. The collection is backed by the map.", "type": "method" },
-        "entrySet": { "signature": "public Set<Map.Entry<K,V>> entrySet()", "description": "Returns a Set view of the mappings contained in this map. Each element is a Map.Entry.", "type": "method" },
-        "size": { "signature": "public int size()", "description": "Returns the number of key-value mappings in this map.", "type": "method" },
-        "isEmpty": { "signature": "public boolean isEmpty()", "description": "Returns true if this map contains no key-value mappings.", "type": "method" },
-        "clear": { "signature": "public void clear()", "description": "Removes all of the mappings from this map. The map will be empty after this call returns.", "type": "method" },
-        "putIfAbsent": { "signature": "public V putIfAbsent(K key, V value)", "description": "If the specified key is not already associated with a value, associates it with the given value and returns null, else returns the current value.", "type": "method" },
-        "computeIfAbsent": { "signature": "public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)", "description": "If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map.", "type": "method" },
-        "merge": { "signature": "public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)", "description": "If the specified key is not already associated with a value, associates it with the given value. Otherwise, replaces the value with the results of the given remapping function.", "type": "method" },
-        "forEach": { "signature": "public void forEach(BiConsumer<? super K, ? super V> action)", "description": "Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.", "type": "method" }
-      }
-    },
-    "Optional": {
-      "signature": "public final class Optional<T>",
-      "description": "A container object which may or may not contain a non-null value. If a value is present, isPresent() returns true. If no value is present, the object is considered empty. Introduced in Java 8 to help avoid NullPointerException.",
-      "type": "class",
-      "module": "java.util",
-      "members": {
-        "of": { "signature": "public static <T> Optional<T> of(T value)", "description": "Returns an Optional describing the given non-null value. Throws NullPointerException if the value is null.", "type": "method" },
-        "ofNullable": { "signature": "public static <T> Optional<T> ofNullable(T value)", "description": "Returns an Optional describing the given value, or an empty Optional if the value is null.", "type": "method" },
-        "empty": { "signature": "public static <T> Optional<T> empty()", "description": "Returns an empty Optional instance. No value is present for this Optional.", "type": "method" },
-        "isPresent": { "signature": "public boolean isPresent()", "description": "Returns true if a value is present, otherwise false.", "type": "method" },
-        "isEmpty": { "signature": "public boolean isEmpty()", "description": "(Java 11+) Returns true if a value is not present, otherwise false.", "type": "method" },
-        "get": { "signature": "public T get()", "description": "If a value is present, returns the value, otherwise throws NoSuchElementException. Prefer orElse/orElseThrow over get().", "type": "method" },
-        "orElse": { "signature": "public T orElse(T other)", "description": "If a value is present, returns the value, otherwise returns other.", "type": "method" },
-        "orElseGet": { "signature": "public T orElseGet(Supplier<? extends T> supplier)", "description": "If a value is present, returns the value, otherwise invokes supplier and returns the result.", "type": "method" },
-        "orElseThrow": { "signature": "public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)", "description": "If a value is present, returns the value, otherwise throws the exception created by the supplier.", "type": "method" },
-        "map": { "signature": "public <U> Optional<U> map(Function<? super T, ? extends U> mapper)", "description": "If a value is present, applies the provided mapping function to it, and if the result is non-null, returns an Optional describing the result.", "type": "method" },
-        "flatMap": { "signature": "public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper)", "description": "If a value is present, applies the provided Optional-bearing mapping function to it and returns the result, otherwise returns an empty Optional.", "type": "method" },
-        "filter": { "signature": "public Optional<T> filter(Predicate<? super T> predicate)", "description": "If a value is present and matches the given predicate, returns an Optional describing the value, otherwise returns an empty Optional.", "type": "method" },
-        "ifPresent": { "signature": "public void ifPresent(Consumer<? super T> action)", "description": "If a value is present, performs the given action with the value, otherwise does nothing.", "type": "method" },
-        "ifPresentOrElse": { "signature": "public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)", "description": "(Java 9+) If a value is present, performs the given action with the value, otherwise performs the given empty-based action.", "type": "method" },
-        "stream": { "signature": "public Stream<T> stream()", "description": "(Java 9+) If a value is present, returns a sequential Stream containing only that value, otherwise returns an empty Stream.", "type": "method" }
-      }
-    },
-    "Stream": {
-      "signature": "public interface Stream<T> extends BaseStream<T, Stream<T>>",
-      "description": "A sequence of elements supporting sequential and parallel aggregate operations. Stream operations are divided into intermediate (lazy) and terminal (eager) operations. Streams are created from collections, arrays, or generator functions.",
-      "type": "interface",
-      "module": "java.util.stream",
-      "members": {
-        "filter": { "signature": "Stream<T> filter(Predicate<? super T> predicate)", "description": "Returns a stream consisting of the elements of this stream that match the given predicate. Intermediate operation.", "type": "method" },
-        "map": { "signature": "<R> Stream<R> map(Function<? super T, ? extends R> mapper)", "description": "Returns a stream consisting of the results of applying the given function to the elements of this stream. Intermediate operation.", "type": "method" },
-        "flatMap": { "signature": "<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)", "description": "Returns a stream of the results of replacing each element with the contents of a mapped stream. Intermediate operation.", "type": "method" },
-        "collect": { "signature": "<R, A> R collect(Collector<? super T, A, R> collector)", "description": "Performs a mutable reduction operation using a Collector. Terminal operation.", "type": "method" },
-        "reduce": { "signature": "T reduce(T identity, BinaryOperator<T> accumulator)", "description": "Performs a reduction on the elements using the given identity value and an associative accumulation function. Terminal operation.", "type": "method" },
-        "forEach": { "signature": "void forEach(Consumer<? super T> action)", "description": "Performs an action for each element of this stream. Terminal operation.", "type": "method" },
-        "sorted": { "signature": "Stream<T> sorted()", "description": "Returns a stream consisting of the elements of this stream, sorted according to natural order. Stateful intermediate operation.", "type": "method" },
-        "distinct": { "signature": "Stream<T> distinct()", "description": "Returns a stream consisting of the distinct elements (according to Object.equals) of this stream. Stateful intermediate operation.", "type": "method" },
-        "limit": { "signature": "Stream<T> limit(long maxSize)", "description": "Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length. Short-circuiting stateful intermediate operation.", "type": "method" },
-        "skip": { "signature": "Stream<T> skip(long n)", "description": "Returns a stream consisting of the remaining elements of this stream after discarding the first n elements. Stateful intermediate operation.", "type": "method" },
-        "count": { "signature": "long count()", "description": "Returns the count of elements in this stream. Terminal operation.", "type": "method" },
-        "findFirst": { "signature": "Optional<T> findFirst()", "description": "Returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty. Short-circuiting terminal operation.", "type": "method" },
-        "findAny": { "signature": "Optional<T> findAny()", "description": "Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty. Non-deterministic in parallel streams. Short-circuiting terminal operation.", "type": "method" },
-        "anyMatch": { "signature": "boolean anyMatch(Predicate<? super T> predicate)", "description": "Returns whether any elements of this stream match the provided predicate. Short-circuiting terminal operation.", "type": "method" },
-        "allMatch": { "signature": "boolean allMatch(Predicate<? super T> predicate)", "description": "Returns whether all elements of this stream match the provided predicate. Short-circuiting terminal operation.", "type": "method" },
-        "noneMatch": { "signature": "boolean noneMatch(Predicate<? super T> predicate)", "description": "Returns whether no elements of this stream match the provided predicate. Short-circuiting terminal operation.", "type": "method" },
-        "toArray": { "signature": "Object[] toArray()", "description": "Returns an array containing the elements of this stream. Terminal operation.", "type": "method" },
-        "peek": { "signature": "Stream<T> peek(Consumer<? super T> action)", "description": "Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as they are consumed. Intermediate operation mainly for debugging.", "type": "method" },
-        "min": { "signature": "Optional<T> min(Comparator<? super T> comparator)", "description": "Returns the minimum element of this stream according to the provided Comparator. Terminal operation.", "type": "method" },
-        "max": { "signature": "Optional<T> max(Comparator<? super T> comparator)", "description": "Returns the maximum element of this stream according to the provided Comparator. Terminal operation.", "type": "method" },
-        "of": { "signature": "static <T> Stream<T> of(T... values)", "description": "Returns a sequential ordered stream whose elements are the specified values.", "type": "method" },
-        "iterate": { "signature": "static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)", "description": "Returns an infinite sequential ordered Stream produced by iterative application of a function f to an initial element seed.", "type": "method" },
-        "generate": { "signature": "static <T> Stream<T> generate(Supplier<? extends T> s)", "description": "Returns an infinite sequential unordered stream where each element is generated by the provided Supplier.", "type": "method" },
-        "concat": { "signature": "static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)", "description": "Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.", "type": "method" }
-      }
-    },
-    "List": {
-      "signature": "public interface List<E> extends Collection<E>",
-      "description": "An ordered collection (also known as a sequence). The user can access elements by their integer index and search for elements in the list. Unlike sets, lists typically allow duplicate elements.",
-      "type": "interface",
-      "module": "java.util",
-      "members": {
-        "of": { "signature": "static <E> List<E> of(E... elements)", "description": "(Java 9+) Returns an unmodifiable list containing the specified elements. Throws NullPointerException if any element is null.", "type": "method" },
-        "copyOf": { "signature": "static <E> List<E> copyOf(Collection<? extends E> coll)", "description": "(Java 10+) Returns an unmodifiable List containing the elements of the given Collection, in its iteration order.", "type": "method" }
-      }
-    },
-    "Map": {
-      "signature": "public interface Map<K,V>",
-      "description": "An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value. This interface takes the place of the Dictionary class.",
-      "type": "interface",
-      "module": "java.util",
-      "members": {
-        "of": { "signature": "static <K,V> Map<K,V> of(K k1, V v1, ...)", "description": "(Java 9+) Returns an unmodifiable map containing the specified key-value pairs. Does not permit null keys or values.", "type": "method" },
-        "ofEntries": { "signature": "static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K, ? extends V>... entries)", "description": "(Java 9+) Returns an unmodifiable map containing keys and values extracted from the given entries. Does not permit duplicate keys.", "type": "method" },
-        "entry": { "signature": "static <K,V> Map.Entry<K,V> entry(K k, V v)", "description": "(Java 9+) Returns an unmodifiable Map.Entry containing the given key and value. These entries are suitable for populating Map instances using the Map.ofEntries() method.", "type": "method" }
-      }
-    },
-    "CompletableFuture": {
-      "signature": "public class CompletableFuture<T> implements Future<T>, CompletionStage<T>",
-      "description": "A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion. Provides a rich API for composing asynchronous operations.",
-      "type": "class",
-      "module": "java.util.concurrent",
-      "members": {
-        "supplyAsync": { "signature": "public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)", "description": "Returns a new CompletableFuture that is asynchronously completed by a task running in the ForkJoinPool.commonPool() with the value obtained by calling the given Supplier.", "type": "method" },
-        "thenApply": { "signature": "public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn)", "description": "Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied function.", "type": "method" },
-        "thenAccept": { "signature": "public CompletableFuture<Void> thenAccept(Consumer<? super T> action)", "description": "Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied action.", "type": "method" },
-        "thenRun": { "signature": "public CompletableFuture<Void> thenRun(Runnable action)", "description": "Returns a new CompletionStage that, when this stage completes normally, executes the given action. The result is not passed to the action.", "type": "method" },
-        "thenCompose": { "signature": "public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn)", "description": "Returns a new CompletionStage that is completed with the same value as the CompletionStage returned by the given function. Equivalent to flatMap for futures.", "type": "method" },
-        "thenCombine": { "signature": "public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T, ? super U, ? extends V> fn)", "description": "Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied function.", "type": "method" },
-        "exceptionally": { "signature": "public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)", "description": "Returns a new CompletableFuture that, when this stage completes exceptionally, is executed with the exception as the argument to the supplied function.", "type": "method" },
-        "join": { "signature": "public T join()", "description": "Returns the result value when complete, or throws an (unchecked) exception if completed exceptionally. Unlike get(), does not throw checked exceptions.", "type": "method" },
-        "get": { "signature": "public T get() throws InterruptedException, ExecutionException", "description": "Waits if necessary for this future to complete, and then returns its result. Throws ExecutionException if the computation threw an exception.", "type": "method" },
-        "allOf": { "signature": "public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)", "description": "Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete.", "type": "method" },
-        "anyOf": { "signature": "public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)", "description": "Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result.", "type": "method" },
-        "completedFuture": { "signature": "public static <U> CompletableFuture<U> completedFuture(U value)", "description": "Returns a new CompletableFuture that is already completed with the given value.", "type": "method" }
-      }
-    }
-  }
-}
+{
+  "language": "java",
+  "definitions": {
+    "String": {
+      "signature": "public final class String implements Serializable, Comparable<String>, CharSequence",
+      "description": "The String class represents character strings. All string literals in Java programs are implemented as instances of this class. Strings are immutable; their values cannot be changed after they are created.",
+      "type": "class",
+      "module": "java.lang",
+      "members": {
+        "length": {
+          "signature": "public int length()",
+          "description": "Returns the length of this string. The length is equal to the number of Unicode code units in the string.",
+          "type": "method"
+        },
+        "charAt": {
+          "signature": "public char charAt(int index)",
+          "description": "Returns the char value at the specified index. An index ranges from 0 to length() - 1.",
+          "type": "method"
+        },
+        "substring": {
+          "signature": "public String substring(int beginIndex, int endIndex)",
+          "description": "Returns a string that is a substring of this string. The substring begins at beginIndex and extends to the character at endIndex - 1.",
+          "type": "method"
+        },
+        "equals": {
+          "signature": "public boolean equals(Object anObject)",
+          "description": "Compares this string to the specified object. Returns true if the argument is a String object with the same character sequence.",
+          "type": "method"
+        },
+        "equalsIgnoreCase": {
+          "signature": "public boolean equalsIgnoreCase(String anotherString)",
+          "description": "Compares this String to another String, ignoring case considerations.",
+          "type": "method"
+        },
+        "compareTo": {
+          "signature": "public int compareTo(String anotherString)",
+          "description": "Compares two strings lexicographically. Returns a negative integer, zero, or positive integer.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "public boolean contains(CharSequence s)",
+          "description": "Returns true if this string contains the specified sequence of char values.",
+          "type": "method"
+        },
+        "startsWith": {
+          "signature": "public boolean startsWith(String prefix)",
+          "description": "Tests if this string starts with the specified prefix.",
+          "type": "method"
+        },
+        "endsWith": {
+          "signature": "public boolean endsWith(String suffix)",
+          "description": "Tests if this string ends with the specified suffix.",
+          "type": "method"
+        },
+        "indexOf": {
+          "signature": "public int indexOf(String str)",
+          "description": "Returns the index within this string of the first occurrence of the specified substring. Returns -1 if not found.",
+          "type": "method"
+        },
+        "lastIndexOf": {
+          "signature": "public int lastIndexOf(String str)",
+          "description": "Returns the index within this string of the last occurrence of the specified substring. Returns -1 if not found.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "public String replace(CharSequence target, CharSequence replacement)",
+          "description": "Replaces each substring of this string that matches the literal target sequence with the specified replacement sequence.",
+          "type": "method"
+        },
+        "replaceAll": {
+          "signature": "public String replaceAll(String regex, String replacement)",
+          "description": "Replaces each substring of this string that matches the given regular expression with the given replacement.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "public String[] split(String regex)",
+          "description": "Splits this string around matches of the given regular expression.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "public String trim()",
+          "description": "Returns a string whose value is this string, with all leading and trailing space removed, where space is defined as any character whose codepoint is less than or equal to 'U+0020'.",
+          "type": "method"
+        },
+        "strip": {
+          "signature": "public String strip()",
+          "description": "(Java 11+) Returns a string whose value is this string, with all leading and trailing white space removed. Uses Character.isWhitespace() for Unicode-aware trimming.",
+          "type": "method"
+        },
+        "toUpperCase": {
+          "signature": "public String toUpperCase()",
+          "description": "Converts all of the characters in this String to upper case using the rules of the default locale.",
+          "type": "method"
+        },
+        "toLowerCase": {
+          "signature": "public String toLowerCase()",
+          "description": "Converts all of the characters in this String to lower case using the rules of the default locale.",
+          "type": "method"
+        },
+        "isEmpty": {
+          "signature": "public boolean isEmpty()",
+          "description": "Returns true if, and only if, length() is 0.",
+          "type": "method"
+        },
+        "isBlank": {
+          "signature": "public boolean isBlank()",
+          "description": "(Java 11+) Returns true if the string is empty or contains only white space codepoints.",
+          "type": "method"
+        },
+        "toCharArray": {
+          "signature": "public char[] toCharArray()",
+          "description": "Converts this string to a new character array.",
+          "type": "method"
+        },
+        "matches": {
+          "signature": "public boolean matches(String regex)",
+          "description": "Tells whether or not this string matches the given regular expression.",
+          "type": "method"
+        },
+        "format": {
+          "signature": "public static String format(String format, Object... args)",
+          "description": "Returns a formatted string using the specified format string and arguments.",
+          "type": "method"
+        },
+        "join": {
+          "signature": "public static String join(CharSequence delimiter, CharSequence... elements)",
+          "description": "Returns a new String composed of copies of the CharSequence elements joined together with the specified delimiter.",
+          "type": "method"
+        },
+        "valueOf": {
+          "signature": "public static String valueOf(Object obj)",
+          "description": "Returns the string representation of the Object argument. Returns \"null\" if the argument is null.",
+          "type": "method"
+        },
+        "repeat": {
+          "signature": "public String repeat(int count)",
+          "description": "(Java 11+) Returns a string whose value is the concatenation of this string repeated count times.",
+          "type": "method"
+        },
+        "chars": {
+          "signature": "public IntStream chars()",
+          "description": "Returns an IntStream of char values from this sequence. The values are zero-extended to int.",
+          "type": "method"
+        }
+      }
+    },
+    "ArrayList": {
+      "signature": "public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable",
+      "description": "Resizable-array implementation of the List interface. Implements all optional list operations and permits all elements, including null. Provides constant-time positional access and amortized constant-time addition.",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "add": {
+          "signature": "public boolean add(E e)",
+          "description": "Appends the specified element to the end of this list. Returns true.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "public E get(int index)",
+          "description": "Returns the element at the specified position in this list. Throws IndexOutOfBoundsException if the index is out of range.",
+          "type": "method"
+        },
+        "set": {
+          "signature": "public E set(int index, E element)",
+          "description": "Replaces the element at the specified position in this list with the specified element. Returns the element previously at the position.",
+          "type": "method"
+        },
+        "remove": {
+          "signature": "public E remove(int index)",
+          "description": "Removes the element at the specified position in this list. Shifts any subsequent elements to the left.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "public int size()",
+          "description": "Returns the number of elements in this list.",
+          "type": "method"
+        },
+        "isEmpty": {
+          "signature": "public boolean isEmpty()",
+          "description": "Returns true if this list contains no elements.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "public boolean contains(Object o)",
+          "description": "Returns true if this list contains the specified element, as determined by equals().",
+          "type": "method"
+        },
+        "indexOf": {
+          "signature": "public int indexOf(Object o)",
+          "description": "Returns the index of the first occurrence of the specified element in this list, or -1 if not found.",
+          "type": "method"
+        },
+        "clear": {
+          "signature": "public void clear()",
+          "description": "Removes all of the elements from this list. The list will be empty after this call returns.",
+          "type": "method"
+        },
+        "sort": {
+          "signature": "public void sort(Comparator<? super E> c)",
+          "description": "Sorts this list according to the order induced by the specified Comparator. The sort is stable.",
+          "type": "method"
+        },
+        "toArray": {
+          "signature": "public Object[] toArray()",
+          "description": "Returns an array containing all of the elements in this list in proper sequence (from first to last element).",
+          "type": "method"
+        },
+        "subList": {
+          "signature": "public List<E> subList(int fromIndex, int toIndex)",
+          "description": "Returns a view of the portion of this list between the specified fromIndex (inclusive) and toIndex (exclusive).",
+          "type": "method"
+        },
+        "iterator": {
+          "signature": "public Iterator<E> iterator()",
+          "description": "Returns an iterator over the elements in this list in proper sequence.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "public void forEach(Consumer<? super E> action)",
+          "description": "Performs the given action for each element of the Iterable until all elements have been processed or the action throws an exception.",
+          "type": "method"
+        },
+        "stream": {
+          "signature": "public Stream<E> stream()",
+          "description": "Returns a sequential Stream with this collection as its source.",
+          "type": "method"
+        },
+        "addAll": {
+          "signature": "public boolean addAll(Collection<? extends E> c)",
+          "description": "Appends all of the elements in the specified collection to the end of this list, in the order returned by the collection's iterator.",
+          "type": "method"
+        }
+      }
+    },
+    "HashMap": {
+      "signature": "public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable",
+      "description": "Hash table based implementation of the Map interface. This implementation permits null values and the null key. Makes no guarantees as to the order of the map. Provides constant-time performance for basic operations (get and put).",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "put": {
+          "signature": "public V put(K key, V value)",
+          "description": "Associates the specified value with the specified key in this map. If the map previously contained a mapping for the key, the old value is replaced.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "public V get(Object key)",
+          "description": "Returns the value to which the specified key is mapped, or null if this map contains no mapping for the key.",
+          "type": "method"
+        },
+        "getOrDefault": {
+          "signature": "public V getOrDefault(Object key, V defaultValue)",
+          "description": "Returns the value to which the specified key is mapped, or defaultValue if this map contains no mapping for the key.",
+          "type": "method"
+        },
+        "remove": {
+          "signature": "public V remove(Object key)",
+          "description": "Removes the mapping for the specified key from this map if present. Returns the previous value, or null.",
+          "type": "method"
+        },
+        "containsKey": {
+          "signature": "public boolean containsKey(Object key)",
+          "description": "Returns true if this map contains a mapping for the specified key.",
+          "type": "method"
+        },
+        "containsValue": {
+          "signature": "public boolean containsValue(Object value)",
+          "description": "Returns true if this map maps one or more keys to the specified value.",
+          "type": "method"
+        },
+        "keySet": {
+          "signature": "public Set<K> keySet()",
+          "description": "Returns a Set view of the keys contained in this map. The set is backed by the map.",
+          "type": "method"
+        },
+        "values": {
+          "signature": "public Collection<V> values()",
+          "description": "Returns a Collection view of the values contained in this map. The collection is backed by the map.",
+          "type": "method"
+        },
+        "entrySet": {
+          "signature": "public Set<Map.Entry<K,V>> entrySet()",
+          "description": "Returns a Set view of the mappings contained in this map. Each element is a Map.Entry.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "public int size()",
+          "description": "Returns the number of key-value mappings in this map.",
+          "type": "method"
+        },
+        "isEmpty": {
+          "signature": "public boolean isEmpty()",
+          "description": "Returns true if this map contains no key-value mappings.",
+          "type": "method"
+        },
+        "clear": {
+          "signature": "public void clear()",
+          "description": "Removes all of the mappings from this map. The map will be empty after this call returns.",
+          "type": "method"
+        },
+        "putIfAbsent": {
+          "signature": "public V putIfAbsent(K key, V value)",
+          "description": "If the specified key is not already associated with a value, associates it with the given value and returns null, else returns the current value.",
+          "type": "method"
+        },
+        "computeIfAbsent": {
+          "signature": "public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)",
+          "description": "If the specified key is not already associated with a value, attempts to compute its value using the given mapping function and enters it into this map.",
+          "type": "method"
+        },
+        "merge": {
+          "signature": "public V merge(K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction)",
+          "description": "If the specified key is not already associated with a value, associates it with the given value. Otherwise, replaces the value with the results of the given remapping function.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "public void forEach(BiConsumer<? super K, ? super V> action)",
+          "description": "Performs the given action for each entry in this map until all entries have been processed or the action throws an exception.",
+          "type": "method"
+        }
+      }
+    },
+    "Optional": {
+      "signature": "public final class Optional<T>",
+      "description": "A container object which may or may not contain a non-null value. If a value is present, isPresent() returns true. If no value is present, the object is considered empty. Introduced in Java 8 to help avoid NullPointerException.",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "of": {
+          "signature": "public static <T> Optional<T> of(T value)",
+          "description": "Returns an Optional describing the given non-null value. Throws NullPointerException if the value is null.",
+          "type": "method"
+        },
+        "ofNullable": {
+          "signature": "public static <T> Optional<T> ofNullable(T value)",
+          "description": "Returns an Optional describing the given value, or an empty Optional if the value is null.",
+          "type": "method"
+        },
+        "empty": {
+          "signature": "public static <T> Optional<T> empty()",
+          "description": "Returns an empty Optional instance. No value is present for this Optional.",
+          "type": "method"
+        },
+        "isPresent": {
+          "signature": "public boolean isPresent()",
+          "description": "Returns true if a value is present, otherwise false.",
+          "type": "method"
+        },
+        "isEmpty": {
+          "signature": "public boolean isEmpty()",
+          "description": "(Java 11+) Returns true if a value is not present, otherwise false.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "public T get()",
+          "description": "If a value is present, returns the value, otherwise throws NoSuchElementException. Prefer orElse/orElseThrow over get().",
+          "type": "method"
+        },
+        "orElse": {
+          "signature": "public T orElse(T other)",
+          "description": "If a value is present, returns the value, otherwise returns other.",
+          "type": "method"
+        },
+        "orElseGet": {
+          "signature": "public T orElseGet(Supplier<? extends T> supplier)",
+          "description": "If a value is present, returns the value, otherwise invokes supplier and returns the result.",
+          "type": "method"
+        },
+        "orElseThrow": {
+          "signature": "public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)",
+          "description": "If a value is present, returns the value, otherwise throws the exception created by the supplier.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "public <U> Optional<U> map(Function<? super T, ? extends U> mapper)",
+          "description": "If a value is present, applies the provided mapping function to it, and if the result is non-null, returns an Optional describing the result.",
+          "type": "method"
+        },
+        "flatMap": {
+          "signature": "public <U> Optional<U> flatMap(Function<? super T, ? extends Optional<? extends U>> mapper)",
+          "description": "If a value is present, applies the provided Optional-bearing mapping function to it and returns the result, otherwise returns an empty Optional.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "public Optional<T> filter(Predicate<? super T> predicate)",
+          "description": "If a value is present and matches the given predicate, returns an Optional describing the value, otherwise returns an empty Optional.",
+          "type": "method"
+        },
+        "ifPresent": {
+          "signature": "public void ifPresent(Consumer<? super T> action)",
+          "description": "If a value is present, performs the given action with the value, otherwise does nothing.",
+          "type": "method"
+        },
+        "ifPresentOrElse": {
+          "signature": "public void ifPresentOrElse(Consumer<? super T> action, Runnable emptyAction)",
+          "description": "(Java 9+) If a value is present, performs the given action with the value, otherwise performs the given empty-based action.",
+          "type": "method"
+        },
+        "stream": {
+          "signature": "public Stream<T> stream()",
+          "description": "(Java 9+) If a value is present, returns a sequential Stream containing only that value, otherwise returns an empty Stream.",
+          "type": "method"
+        }
+      }
+    },
+    "Stream": {
+      "signature": "public interface Stream<T> extends BaseStream<T, Stream<T>>",
+      "description": "A sequence of elements supporting sequential and parallel aggregate operations. Stream operations are divided into intermediate (lazy) and terminal (eager) operations. Streams are created from collections, arrays, or generator functions.",
+      "type": "interface",
+      "module": "java.util.stream",
+      "members": {
+        "filter": {
+          "signature": "Stream<T> filter(Predicate<? super T> predicate)",
+          "description": "Returns a stream consisting of the elements of this stream that match the given predicate. Intermediate operation.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "<R> Stream<R> map(Function<? super T, ? extends R> mapper)",
+          "description": "Returns a stream consisting of the results of applying the given function to the elements of this stream. Intermediate operation.",
+          "type": "method"
+        },
+        "flatMap": {
+          "signature": "<R> Stream<R> flatMap(Function<? super T, ? extends Stream<? extends R>> mapper)",
+          "description": "Returns a stream of the results of replacing each element with the contents of a mapped stream. Intermediate operation.",
+          "type": "method"
+        },
+        "collect": {
+          "signature": "<R, A> R collect(Collector<? super T, A, R> collector)",
+          "description": "Performs a mutable reduction operation using a Collector. Terminal operation.",
+          "type": "method"
+        },
+        "reduce": {
+          "signature": "T reduce(T identity, BinaryOperator<T> accumulator)",
+          "description": "Performs a reduction on the elements using the given identity value and an associative accumulation function. Terminal operation.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "void forEach(Consumer<? super T> action)",
+          "description": "Performs an action for each element of this stream. Terminal operation.",
+          "type": "method"
+        },
+        "sorted": {
+          "signature": "Stream<T> sorted()",
+          "description": "Returns a stream consisting of the elements of this stream, sorted according to natural order. Stateful intermediate operation.",
+          "type": "method"
+        },
+        "distinct": {
+          "signature": "Stream<T> distinct()",
+          "description": "Returns a stream consisting of the distinct elements (according to Object.equals) of this stream. Stateful intermediate operation.",
+          "type": "method"
+        },
+        "limit": {
+          "signature": "Stream<T> limit(long maxSize)",
+          "description": "Returns a stream consisting of the elements of this stream, truncated to be no longer than maxSize in length. Short-circuiting stateful intermediate operation.",
+          "type": "method"
+        },
+        "skip": {
+          "signature": "Stream<T> skip(long n)",
+          "description": "Returns a stream consisting of the remaining elements of this stream after discarding the first n elements. Stateful intermediate operation.",
+          "type": "method"
+        },
+        "count": {
+          "signature": "long count()",
+          "description": "Returns the count of elements in this stream. Terminal operation.",
+          "type": "method"
+        },
+        "findFirst": {
+          "signature": "Optional<T> findFirst()",
+          "description": "Returns an Optional describing the first element of this stream, or an empty Optional if the stream is empty. Short-circuiting terminal operation.",
+          "type": "method"
+        },
+        "findAny": {
+          "signature": "Optional<T> findAny()",
+          "description": "Returns an Optional describing some element of the stream, or an empty Optional if the stream is empty. Non-deterministic in parallel streams. Short-circuiting terminal operation.",
+          "type": "method"
+        },
+        "anyMatch": {
+          "signature": "boolean anyMatch(Predicate<? super T> predicate)",
+          "description": "Returns whether any elements of this stream match the provided predicate. Short-circuiting terminal operation.",
+          "type": "method"
+        },
+        "allMatch": {
+          "signature": "boolean allMatch(Predicate<? super T> predicate)",
+          "description": "Returns whether all elements of this stream match the provided predicate. Short-circuiting terminal operation.",
+          "type": "method"
+        },
+        "noneMatch": {
+          "signature": "boolean noneMatch(Predicate<? super T> predicate)",
+          "description": "Returns whether no elements of this stream match the provided predicate. Short-circuiting terminal operation.",
+          "type": "method"
+        },
+        "toArray": {
+          "signature": "Object[] toArray()",
+          "description": "Returns an array containing the elements of this stream. Terminal operation.",
+          "type": "method"
+        },
+        "peek": {
+          "signature": "Stream<T> peek(Consumer<? super T> action)",
+          "description": "Returns a stream consisting of the elements of this stream, additionally performing the provided action on each element as they are consumed. Intermediate operation mainly for debugging.",
+          "type": "method"
+        },
+        "min": {
+          "signature": "Optional<T> min(Comparator<? super T> comparator)",
+          "description": "Returns the minimum element of this stream according to the provided Comparator. Terminal operation.",
+          "type": "method"
+        },
+        "max": {
+          "signature": "Optional<T> max(Comparator<? super T> comparator)",
+          "description": "Returns the maximum element of this stream according to the provided Comparator. Terminal operation.",
+          "type": "method"
+        },
+        "of": {
+          "signature": "static <T> Stream<T> of(T... values)",
+          "description": "Returns a sequential ordered stream whose elements are the specified values.",
+          "type": "method"
+        },
+        "iterate": {
+          "signature": "static <T> Stream<T> iterate(T seed, UnaryOperator<T> f)",
+          "description": "Returns an infinite sequential ordered Stream produced by iterative application of a function f to an initial element seed.",
+          "type": "method"
+        },
+        "generate": {
+          "signature": "static <T> Stream<T> generate(Supplier<? extends T> s)",
+          "description": "Returns an infinite sequential unordered stream where each element is generated by the provided Supplier.",
+          "type": "method"
+        },
+        "concat": {
+          "signature": "static <T> Stream<T> concat(Stream<? extends T> a, Stream<? extends T> b)",
+          "description": "Creates a lazily concatenated stream whose elements are all the elements of the first stream followed by all the elements of the second stream.",
+          "type": "method"
+        }
+      }
+    },
+    "List": {
+      "signature": "public interface List<E> extends Collection<E>",
+      "description": "An ordered collection (also known as a sequence). The user can access elements by their integer index and search for elements in the list. Unlike sets, lists typically allow duplicate elements.",
+      "type": "interface",
+      "module": "java.util",
+      "members": {
+        "of": {
+          "signature": "static <E> List<E> of(E... elements)",
+          "description": "(Java 9+) Returns an unmodifiable list containing the specified elements. Throws NullPointerException if any element is null.",
+          "type": "method"
+        },
+        "copyOf": {
+          "signature": "static <E> List<E> copyOf(Collection<? extends E> coll)",
+          "description": "(Java 10+) Returns an unmodifiable List containing the elements of the given Collection, in its iteration order.",
+          "type": "method"
+        }
+      }
+    },
+    "Map": {
+      "signature": "public interface Map<K,V>",
+      "description": "An object that maps keys to values. A map cannot contain duplicate keys; each key can map to at most one value. This interface takes the place of the Dictionary class.",
+      "type": "interface",
+      "module": "java.util",
+      "members": {
+        "of": {
+          "signature": "static <K,V> Map<K,V> of(K k1, V v1, ...)",
+          "description": "(Java 9+) Returns an unmodifiable map containing the specified key-value pairs. Does not permit null keys or values.",
+          "type": "method"
+        },
+        "ofEntries": {
+          "signature": "static <K,V> Map<K,V> ofEntries(Map.Entry<? extends K, ? extends V>... entries)",
+          "description": "(Java 9+) Returns an unmodifiable map containing keys and values extracted from the given entries. Does not permit duplicate keys.",
+          "type": "method"
+        },
+        "entry": {
+          "signature": "static <K,V> Map.Entry<K,V> entry(K k, V v)",
+          "description": "(Java 9+) Returns an unmodifiable Map.Entry containing the given key and value. These entries are suitable for populating Map instances using the Map.ofEntries() method.",
+          "type": "method"
+        }
+      }
+    },
+    "CompletableFuture": {
+      "signature": "public class CompletableFuture<T> implements Future<T>, CompletionStage<T>",
+      "description": "A Future that may be explicitly completed (setting its value and status), and may be used as a CompletionStage, supporting dependent functions and actions that trigger upon its completion. Provides a rich API for composing asynchronous operations.",
+      "type": "class",
+      "module": "java.util.concurrent",
+      "members": {
+        "supplyAsync": {
+          "signature": "public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier)",
+          "description": "Returns a new CompletableFuture that is asynchronously completed by a task running in the ForkJoinPool.commonPool() with the value obtained by calling the given Supplier.",
+          "type": "method"
+        },
+        "thenApply": {
+          "signature": "public <U> CompletableFuture<U> thenApply(Function<? super T, ? extends U> fn)",
+          "description": "Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied function.",
+          "type": "method"
+        },
+        "thenAccept": {
+          "signature": "public CompletableFuture<Void> thenAccept(Consumer<? super T> action)",
+          "description": "Returns a new CompletionStage that, when this stage completes normally, is executed with this stage's result as the argument to the supplied action.",
+          "type": "method"
+        },
+        "thenRun": {
+          "signature": "public CompletableFuture<Void> thenRun(Runnable action)",
+          "description": "Returns a new CompletionStage that, when this stage completes normally, executes the given action. The result is not passed to the action.",
+          "type": "method"
+        },
+        "thenCompose": {
+          "signature": "public <U> CompletableFuture<U> thenCompose(Function<? super T, ? extends CompletionStage<U>> fn)",
+          "description": "Returns a new CompletionStage that is completed with the same value as the CompletionStage returned by the given function. Equivalent to flatMap for futures.",
+          "type": "method"
+        },
+        "thenCombine": {
+          "signature": "public <U,V> CompletableFuture<V> thenCombine(CompletionStage<? extends U> other, BiFunction<? super T, ? super U, ? extends V> fn)",
+          "description": "Returns a new CompletionStage that, when this and the other given stage both complete normally, is executed with the two results as arguments to the supplied function.",
+          "type": "method"
+        },
+        "exceptionally": {
+          "signature": "public CompletableFuture<T> exceptionally(Function<Throwable, ? extends T> fn)",
+          "description": "Returns a new CompletableFuture that, when this stage completes exceptionally, is executed with the exception as the argument to the supplied function.",
+          "type": "method"
+        },
+        "join": {
+          "signature": "public T join()",
+          "description": "Returns the result value when complete, or throws an (unchecked) exception if completed exceptionally. Unlike get(), does not throw checked exceptions.",
+          "type": "method"
+        },
+        "get": {
+          "signature": "public T get() throws InterruptedException, ExecutionException",
+          "description": "Waits if necessary for this future to complete, and then returns its result. Throws ExecutionException if the computation threw an exception.",
+          "type": "method"
+        },
+        "allOf": {
+          "signature": "public static CompletableFuture<Void> allOf(CompletableFuture<?>... cfs)",
+          "description": "Returns a new CompletableFuture that is completed when all of the given CompletableFutures complete.",
+          "type": "method"
+        },
+        "anyOf": {
+          "signature": "public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs)",
+          "description": "Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result.",
+          "type": "method"
+        },
+        "completedFuture": {
+          "signature": "public static <U> CompletableFuture<U> completedFuture(U value)",
+          "description": "Returns a new CompletableFuture that is already completed with the given value.",
+          "type": "method"
+        }
+      }
+    },
+    "Math": {
+      "signature": "public final class Math",
+      "description": "Contains methods for performing basic numeric operations such as exponentiation, logarithm, square root, and trigonometry.",
+      "type": "class",
+      "module": "java.lang",
+      "members": {
+        "abs": {
+          "signature": "static int abs(int a)",
+          "description": "Returns the absolute value.",
+          "type": "method",
+          "returns": "int"
+        },
+        "max": {
+          "signature": "static int max(int a, int b)",
+          "description": "Returns the greater of two values.",
+          "type": "method",
+          "returns": "int"
+        },
+        "min": {
+          "signature": "static int min(int a, int b)",
+          "description": "Returns the smaller of two values.",
+          "type": "method",
+          "returns": "int"
+        },
+        "pow": {
+          "signature": "static double pow(double a, double b)",
+          "description": "Returns the value of the first argument raised to the power of the second argument.",
+          "type": "method",
+          "returns": "double"
+        },
+        "sqrt": {
+          "signature": "static double sqrt(double a)",
+          "description": "Returns the correctly rounded positive square root.",
+          "type": "method",
+          "returns": "double"
+        },
+        "random": {
+          "signature": "static double random()",
+          "description": "Returns a pseudorandom double value between 0.0 and 1.0.",
+          "type": "method",
+          "returns": "double"
+        },
+        "ceil": {
+          "signature": "static double ceil(double a)",
+          "description": "Returns the smallest double that is greater than or equal to the argument and is an integer.",
+          "type": "method",
+          "returns": "double"
+        },
+        "floor": {
+          "signature": "static double floor(double a)",
+          "description": "Returns the largest double that is less than or equal to the argument and is an integer.",
+          "type": "method",
+          "returns": "double"
+        },
+        "round": {
+          "signature": "static long round(double a)",
+          "description": "Returns the closest long to the argument.",
+          "type": "method",
+          "returns": "long"
+        },
+        "log": {
+          "signature": "static double log(double a)",
+          "description": "Returns the natural logarithm (base e).",
+          "type": "method",
+          "returns": "double"
+        },
+        "PI": {
+          "signature": "static final double PI",
+          "description": "The double value closer to pi than any other.",
+          "type": "property",
+          "returns": "double"
+        }
+      }
+    },
+    "StringBuilder": {
+      "signature": "public final class StringBuilder extends AbstractStringBuilder",
+      "description": "A mutable sequence of characters. Unlike String, StringBuilder can be modified after creation.",
+      "type": "class",
+      "module": "java.lang",
+      "members": {
+        "append": {
+          "signature": "StringBuilder append(String str)",
+          "description": "Appends the specified string.",
+          "type": "method",
+          "returns": "StringBuilder"
+        },
+        "insert": {
+          "signature": "StringBuilder insert(int offset, String str)",
+          "description": "Inserts the string at the specified offset.",
+          "type": "method",
+          "returns": "StringBuilder"
+        },
+        "delete": {
+          "signature": "StringBuilder delete(int start, int end)",
+          "description": "Removes characters in a substring.",
+          "type": "method",
+          "returns": "StringBuilder"
+        },
+        "replace": {
+          "signature": "StringBuilder replace(int start, int end, String str)",
+          "description": "Replaces characters in a substring.",
+          "type": "method",
+          "returns": "StringBuilder"
+        },
+        "reverse": {
+          "signature": "StringBuilder reverse()",
+          "description": "Reverses the character sequence.",
+          "type": "method",
+          "returns": "StringBuilder"
+        },
+        "toString": {
+          "signature": "String toString()",
+          "description": "Returns a string representation.",
+          "type": "method",
+          "returns": "String"
+        },
+        "length": {
+          "signature": "int length()",
+          "description": "Returns the length (character count).",
+          "type": "method",
+          "returns": "int"
+        },
+        "charAt": {
+          "signature": "char charAt(int index)",
+          "description": "Returns the char value at the specified index.",
+          "type": "method",
+          "returns": "char"
+        }
+      }
+    },
+    "Arrays": {
+      "signature": "public class Arrays",
+      "description": "Contains static methods for manipulating arrays (sorting, searching, comparing, filling).",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "sort": {
+          "signature": "static void sort(int[] a)",
+          "description": "Sorts the specified array into ascending numerical order.",
+          "type": "method",
+          "returns": "void"
+        },
+        "binarySearch": {
+          "signature": "static int binarySearch(int[] a, int key)",
+          "description": "Searches the specified sorted array for the specified value using binary search.",
+          "type": "method",
+          "returns": "int"
+        },
+        "copyOf": {
+          "signature": "static int[] copyOf(int[] original, int newLength)",
+          "description": "Copies the specified array, truncating or padding with zeros as necessary.",
+          "type": "method",
+          "returns": "int[]"
+        },
+        "asList": {
+          "signature": "static <T> List<T> asList(T... a)",
+          "description": "Returns a fixed-size list backed by the specified array.",
+          "type": "method",
+          "returns": "List<T>"
+        },
+        "fill": {
+          "signature": "static void fill(int[] a, int val)",
+          "description": "Assigns the specified value to each element.",
+          "type": "method",
+          "returns": "void"
+        },
+        "equals": {
+          "signature": "static boolean equals(int[] a, int[] a2)",
+          "description": "Returns true if the two arrays are equal.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "stream": {
+          "signature": "static IntStream stream(int[] array)",
+          "description": "Returns a sequential IntStream with the specified array as source.",
+          "type": "method",
+          "returns": "IntStream"
+        },
+        "toString": {
+          "signature": "static String toString(int[] a)",
+          "description": "Returns a string representation of the contents.",
+          "type": "method",
+          "returns": "String"
+        }
+      }
+    },
+    "Collections": {
+      "signature": "public class Collections",
+      "description": "Consists exclusively of static methods that operate on or return collections.",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "sort": {
+          "signature": "static <T extends Comparable<? super T>> void sort(List<T> list)",
+          "description": "Sorts the specified list into ascending order.",
+          "type": "method",
+          "returns": "void"
+        },
+        "reverse": {
+          "signature": "static void reverse(List<?> list)",
+          "description": "Reverses the order of elements.",
+          "type": "method",
+          "returns": "void"
+        },
+        "shuffle": {
+          "signature": "static void shuffle(List<?> list)",
+          "description": "Randomly permutes the specified list.",
+          "type": "method",
+          "returns": "void"
+        },
+        "min": {
+          "signature": "static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)",
+          "description": "Returns the minimum element.",
+          "type": "method",
+          "returns": "T"
+        },
+        "max": {
+          "signature": "static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)",
+          "description": "Returns the maximum element.",
+          "type": "method",
+          "returns": "T"
+        },
+        "unmodifiableList": {
+          "signature": "static <T> List<T> unmodifiableList(List<? extends T> list)",
+          "description": "Returns an unmodifiable view.",
+          "type": "method",
+          "returns": "List<T>"
+        },
+        "synchronizedList": {
+          "signature": "static <T> List<T> synchronizedList(List<T> list)",
+          "description": "Returns a synchronized (thread-safe) list.",
+          "type": "method",
+          "returns": "List<T>"
+        },
+        "frequency": {
+          "signature": "static int frequency(Collection<?> c, Object o)",
+          "description": "Returns the number of elements equal to the specified object.",
+          "type": "method",
+          "returns": "int"
+        },
+        "singletonList": {
+          "signature": "static <T> List<T> singletonList(T o)",
+          "description": "Returns an immutable list containing only the specified object.",
+          "type": "method",
+          "returns": "List<T>"
+        },
+        "emptyList": {
+          "signature": "static <T> List<T> emptyList()",
+          "description": "Returns an empty immutable list.",
+          "type": "method",
+          "returns": "List<T>"
+        }
+      }
+    },
+    "File": {
+      "signature": "public class File implements Serializable, Comparable<File>",
+      "description": "An abstract representation of file and directory pathnames.",
+      "type": "class",
+      "module": "java.io",
+      "members": {
+        "exists": {
+          "signature": "boolean exists()",
+          "description": "Tests whether the file or directory denoted by this pathname exists.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "getName": {
+          "signature": "String getName()",
+          "description": "Returns the name of the file or directory.",
+          "type": "method",
+          "returns": "String"
+        },
+        "getPath": {
+          "signature": "String getPath()",
+          "description": "Converts this pathname into a pathname string.",
+          "type": "method",
+          "returns": "String"
+        },
+        "getAbsolutePath": {
+          "signature": "String getAbsolutePath()",
+          "description": "Returns the absolute pathname string.",
+          "type": "method",
+          "returns": "String"
+        },
+        "isFile": {
+          "signature": "boolean isFile()",
+          "description": "Tests whether the file denoted by this pathname is a normal file.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "isDirectory": {
+          "signature": "boolean isDirectory()",
+          "description": "Tests whether it denotes a directory.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "length": {
+          "signature": "long length()",
+          "description": "Returns the length of the file in bytes.",
+          "type": "method",
+          "returns": "long"
+        },
+        "mkdir": {
+          "signature": "boolean mkdir()",
+          "description": "Creates the directory.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "delete": {
+          "signature": "boolean delete()",
+          "description": "Deletes the file or directory.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "listFiles": {
+          "signature": "File[] listFiles()",
+          "description": "Returns an array of pathnames denoting the files in the directory.",
+          "type": "method",
+          "returns": "File[]"
+        },
+        "createNewFile": {
+          "signature": "boolean createNewFile()",
+          "description": "Atomically creates a new empty file named by this pathname.",
+          "type": "method",
+          "returns": "boolean"
+        }
+      }
+    },
+    "Thread": {
+      "signature": "public class Thread implements Runnable",
+      "description": "A thread is a thread of execution in a program. The JVM allows an application to have multiple threads running concurrently.",
+      "type": "class",
+      "module": "java.lang",
+      "members": {
+        "start": {
+          "signature": "void start()",
+          "description": "Causes this thread to begin execution.",
+          "type": "method",
+          "returns": "void"
+        },
+        "run": {
+          "signature": "void run()",
+          "description": "The entry point for the thread.",
+          "type": "method",
+          "returns": "void"
+        },
+        "sleep": {
+          "signature": "static void sleep(long millis)",
+          "description": "Causes the currently executing thread to sleep.",
+          "type": "method",
+          "returns": "void"
+        },
+        "join": {
+          "signature": "void join()",
+          "description": "Waits for this thread to die.",
+          "type": "method",
+          "returns": "void"
+        },
+        "interrupt": {
+          "signature": "void interrupt()",
+          "description": "Interrupts this thread.",
+          "type": "method",
+          "returns": "void"
+        },
+        "isAlive": {
+          "signature": "boolean isAlive()",
+          "description": "Tests if this thread is alive.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "getName": {
+          "signature": "String getName()",
+          "description": "Returns this thread's name.",
+          "type": "method",
+          "returns": "String"
+        },
+        "currentThread": {
+          "signature": "static Thread currentThread()",
+          "description": "Returns a reference to the currently executing thread.",
+          "type": "method",
+          "returns": "Thread"
+        }
+      }
+    },
+    "Scanner": {
+      "signature": "public final class Scanner implements Iterator<String>, Closeable",
+      "description": "A simple text scanner which can parse primitive types and strings using regular expressions.",
+      "type": "class",
+      "module": "java.util",
+      "members": {
+        "nextLine": {
+          "signature": "String nextLine()",
+          "description": "Advances past the current line and returns the input that was skipped.",
+          "type": "method",
+          "returns": "String"
+        },
+        "nextInt": {
+          "signature": "int nextInt()",
+          "description": "Scans the next token as an int.",
+          "type": "method",
+          "returns": "int"
+        },
+        "nextDouble": {
+          "signature": "double nextDouble()",
+          "description": "Scans the next token as a double.",
+          "type": "method",
+          "returns": "double"
+        },
+        "hasNext": {
+          "signature": "boolean hasNext()",
+          "description": "Returns true if there is another token in input.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "hasNextLine": {
+          "signature": "boolean hasNextLine()",
+          "description": "Returns true if there is another line in input.",
+          "type": "method",
+          "returns": "boolean"
+        },
+        "close": {
+          "signature": "void close()",
+          "description": "Closes this scanner.",
+          "type": "method",
+          "returns": "void"
+        }
+      }
+    },
+    "Integer": {
+      "signature": "public final class Integer extends Number implements Comparable<Integer>",
+      "description": "Wraps a value of the primitive type int. Provides methods for converting between int and String.",
+      "type": "class",
+      "module": "java.lang",
+      "members": {
+        "parseInt": {
+          "signature": "static int parseInt(String s)",
+          "description": "Parses the string argument as a signed decimal integer.",
+          "type": "method",
+          "returns": "int"
+        },
+        "valueOf": {
+          "signature": "static Integer valueOf(int i)",
+          "description": "Returns an Integer instance representing the specified int.",
+          "type": "method",
+          "returns": "Integer"
+        },
+        "toString": {
+          "signature": "static String toString(int i)",
+          "description": "Returns a String object representing the specified integer.",
+          "type": "method",
+          "returns": "String"
+        },
+        "compareTo": {
+          "signature": "int compareTo(Integer anotherInteger)",
+          "description": "Compares two Integer objects numerically.",
+          "type": "method",
+          "returns": "int"
+        },
+        "MAX_VALUE": {
+          "signature": "static final int MAX_VALUE",
+          "description": "The maximum value an int can have, 2^31-1.",
+          "type": "property",
+          "returns": "int"
+        },
+        "MIN_VALUE": {
+          "signature": "static final int MIN_VALUE",
+          "description": "The minimum value an int can have, -2^31.",
+          "type": "property",
+          "returns": "int"
+        },
+        "intValue": {
+          "signature": "int intValue()",
+          "description": "Returns the value of this Integer as an int.",
+          "type": "method",
+          "returns": "int"
+        },
+        "toBinaryString": {
+          "signature": "static String toBinaryString(int i)",
+          "description": "Returns a string representation of the integer in base 2.",
+          "type": "method",
+          "returns": "String"
+        }
+      }
+    },
+    "Number": {
+      "signature": "Number",
+      "description": "Numeric data type for integer and floating-point values.",
+      "type": "type"
+    },
+    "Boolean": {
+      "signature": "Boolean",
+      "description": "Logical type with two values: true and false.",
+      "type": "type"
+    },
+    "Array": {
+      "signature": "Array",
+      "description": "Ordered collection of elements accessible by index.",
+      "type": "type"
+    },
+    "Object": {
+      "signature": "Object",
+      "description": "Collection of key-value pairs (properties and methods).",
+      "type": "type"
+    },
+    "null": {
+      "signature": "null",
+      "description": "Represents the intentional absence of any value.",
+      "type": "constant"
+    },
+    "undefined": {
+      "signature": "undefined",
+      "description": "Represents an uninitialized or missing value.",
+      "type": "constant"
+    }
+  }
+}