@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/kotlin.json

@@ -1,789 +1,269 @@
-{
-  "language": "kotlin",
-  "definitions": {
-    "println": {
-      "signature": "fun println(message: Any?): Unit",
-      "description": "Prints the given message and a newline to standard output",
-      "type": "function",
-      "module": "kotlin.io",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.io/println.html"
-    },
-    "print": {
-      "signature": "fun print(message: Any?): Unit",
-      "description": "Prints the given message to standard output without a newline",
-      "type": "function",
-      "module": "kotlin.io",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.io/print.html"
-    },
-    "readLine": {
-      "signature": "fun readLine(): String?",
-      "description": "Reads a line from standard input, returns null if EOF reached",
-      "type": "function",
-      "module": "kotlin.io",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.io/read-line.html"
-    },
-    "listOf": {
-      "signature": "fun <T> listOf(vararg elements: T): List<T>",
-      "description": "Returns a new read-only list of given elements",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/list-of.html"
-    },
-    "mutableListOf": {
-      "signature": "fun <T> mutableListOf(vararg elements: T): MutableList<T>",
-      "description": "Returns a new MutableList with the given elements",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/mutable-list-of.html"
-    },
-    "mapOf": {
-      "signature": "fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>",
-      "description": "Returns a new read-only map with the specified key-value pairs",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/map-of.html"
-    },
-    "mutableMapOf": {
-      "signature": "fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>",
-      "description": "Returns a new MutableMap with the specified key-value pairs",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/mutable-map-of.html"
-    },
-    "setOf": {
-      "signature": "fun <T> setOf(vararg elements: T): Set<T>",
-      "description": "Returns a new read-only set with the given elements",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/set-of.html"
-    },
-    "mutableSetOf": {
-      "signature": "fun <T> mutableSetOf(vararg elements: T): MutableSet<T>",
-      "description": "Returns a new MutableSet with the given elements",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/mutable-set-of.html"
-    },
-    "arrayOf": {
-      "signature": "fun <T> arrayOf(vararg elements: T): Array<T>",
-      "description": "Returns an array containing the specified elements",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/array-of.html"
-    },
-    "intArrayOf": {
-      "signature": "fun intArrayOf(vararg elements: Int): IntArray",
-      "description": "Returns an IntArray containing the specified elements",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/int-array-of.html"
-    },
-    "let": {
-      "signature": "fun <T, R> T.let(block: (T) -> R): R",
-      "description": "Calls the specified function block with this value as its argument and returns its result",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/let.html"
-    },
-    "run": {
-      "signature": "fun <T, R> T.run(block: T.() -> R): R",
-      "description": "Calls the specified function block with this value as its receiver and returns its result",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/run.html"
-    },
-    "with": {
-      "signature": "fun <T, R> with(receiver: T, block: T.() -> R): R",
-      "description": "Calls the specified function block with the given receiver as its receiver and returns its result",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/with.html"
-    },
-    "apply": {
-      "signature": "fun <T> T.apply(block: T.() -> Unit): T",
-      "description": "Calls the specified function block with this value as its receiver and returns this value",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/apply.html"
-    },
-    "also": {
-      "signature": "fun <T> T.also(block: (T) -> Unit): T",
-      "description": "Calls the specified function block with this value as its argument and returns this value",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/also.html"
-    },
-    "takeIf": {
-      "signature": "fun <T> T.takeIf(predicate: (T) -> Boolean): T?",
-      "description": "Returns this value if it satisfies the given predicate or null if it doesn't",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/take-if.html"
-    },
-    "takeUnless": {
-      "signature": "fun <T> T.takeUnless(predicate: (T) -> Boolean): T?",
-      "description": "Returns this value if it does not satisfy the given predicate or null if it does",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/take-unless.html"
-    },
-    "repeat": {
-      "signature": "fun repeat(times: Int, action: (Int) -> Unit)",
-      "description": "Executes the given function action specified number of times",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/repeat.html"
-    },
-    "require": {
-      "signature": "fun require(value: Boolean, lazyMessage: () -> Any): Unit",
-      "description": "Throws an IllegalArgumentException if the value is false",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/require.html"
-    },
-    "check": {
-      "signature": "fun check(value: Boolean, lazyMessage: () -> Any): Unit",
-      "description": "Throws an IllegalStateException if the value is false",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/check.html"
-    },
-    "error": {
-      "signature": "fun error(message: Any): Nothing",
-      "description": "Throws an IllegalStateException with the given message",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/error.html"
-    },
-    "TODO": {
-      "signature": "fun TODO(reason: String): Nothing",
-      "description": "Always throws NotImplementedError stating that operation is not implemented",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-t-o-d-o.html"
-    },
-    "lazy": {
-      "signature": "fun <T> lazy(initializer: () -> T): Lazy<T>",
-      "description": "Creates a new instance of Lazy that uses the specified initialization function",
-      "type": "function",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/lazy.html"
-    },
-    "sequence": {
-      "signature": "fun <T> sequence(block: suspend SequenceScope<T>.() -> Unit): Sequence<T>",
-      "description": "Builds a Sequence lazily yielding values one by one",
-      "type": "function",
-      "module": "kotlin.sequences",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/sequence.html"
-    },
-    "buildList": {
-      "signature": "fun <E> buildList(builderAction: MutableList<E>.() -> Unit): List<E>",
-      "description": "Builds a new read-only List by populating a MutableList using the given builder action",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/build-list.html"
-    },
-    "buildMap": {
-      "signature": "fun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>",
-      "description": "Builds a new read-only Map by populating a MutableMap using the given builder action",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/build-map.html"
-    },
-    "buildSet": {
-      "signature": "fun <E> buildSet(builderAction: MutableSet<E>.() -> Unit): Set<E>",
-      "description": "Builds a new read-only Set by populating a MutableSet using the given builder action",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/build-set.html"
-    },
-    "emptyList": {
-      "signature": "fun <T> emptyList(): List<T>",
-      "description": "Returns an empty read-only list",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/empty-list.html"
-    },
-    "emptyMap": {
-      "signature": "fun <K, V> emptyMap(): Map<K, V>",
-      "description": "Returns an empty read-only map",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/empty-map.html"
-    },
-    "emptySet": {
-      "signature": "fun <T> emptySet(): Set<T>",
-      "description": "Returns an empty read-only set",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/empty-set.html"
-    },
-    "forEach": {
-      "signature": "fun <T> Iterable<T>.forEach(action: (T) -> Unit)",
-      "description": "Performs the given action on each element",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/for-each.html"
-    },
-    "map": {
-      "signature": "fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>",
-      "description": "Returns a list containing the results of applying the given transform function to each element",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/map.html"
-    },
-    "filter": {
-      "signature": "fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>",
-      "description": "Returns a list containing only elements matching the given predicate",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/filter.html"
-    },
-    "flatMap": {
-      "signature": "fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>",
-      "description": "Returns a single list of all elements yielded from results of transform function being invoked on each element",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/flat-map.html"
-    },
-    "reduce": {
-      "signature": "fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S",
-      "description": "Accumulates value starting with the first element and applying operation from left to right",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/reduce.html"
-    },
-    "fold": {
-      "signature": "fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R",
-      "description": "Accumulates value starting with initial value and applying operation from left to right",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/fold.html"
-    },
-    "groupBy": {
-      "signature": "fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>",
-      "description": "Groups elements of the collection by the key returned by the given function",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/group-by.html"
-    },
-    "sortedBy": {
-      "signature": "fun <T, R : Comparable<R>> Iterable<T>.sortedBy(selector: (T) -> R?): List<T>",
-      "description": "Returns a list of all elements sorted according to natural sort order of the value returned by the selector",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/sorted-by.html"
-    },
-    "associate": {
-      "signature": "fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>",
-      "description": "Returns a Map containing key-value pairs provided by transform function applied to elements",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/associate.html"
-    },
-    "first": {
-      "signature": "fun <T> Iterable<T>.first(): T",
-      "description": "Returns the first element, throws NoSuchElementException if empty",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/first.html"
-    },
-    "firstOrNull": {
-      "signature": "fun <T> Iterable<T>.firstOrNull(): T?",
-      "description": "Returns the first element, or null if the collection is empty",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/first-or-null.html"
-    },
-    "any": {
-      "signature": "fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean",
-      "description": "Returns true if at least one element matches the given predicate",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/any.html"
-    },
-    "all": {
-      "signature": "fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean",
-      "description": "Returns true if all elements match the given predicate",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/all.html"
-    },
-    "none": {
-      "signature": "fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean",
-      "description": "Returns true if no elements match the given predicate",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/none.html"
-    },
-    "count": {
-      "signature": "fun <T> Iterable<T>.count(): Int",
-      "description": "Returns the number of elements in the collection",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/count.html"
-    },
-    "joinToString": {
-      "signature": "fun <T> Iterable<T>.joinToString(separator: CharSequence = \", \"): String",
-      "description": "Creates a string from all the elements separated using separator",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/join-to-string.html"
-    },
-    "toList": {
-      "signature": "fun <T> Iterable<T>.toList(): List<T>",
-      "description": "Returns a List containing all elements",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/to-list.html"
-    },
-    "toMutableList": {
-      "signature": "fun <T> Iterable<T>.toMutableList(): MutableList<T>",
-      "description": "Returns a MutableList filled with all elements of this collection",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/to-mutable-list.html"
-    },
-    "toSet": {
-      "signature": "fun <T> Iterable<T>.toSet(): Set<T>",
-      "description": "Returns a Set of all elements",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/to-set.html"
-    },
-    "toMap": {
-      "signature": "fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>",
-      "description": "Returns a new map containing all key-value pairs from the given collection of pairs",
-      "type": "function",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/to-map.html"
-    },
-    "toInt": {
-      "signature": "fun String.toInt(): Int",
-      "description": "Parses the string as a signed Int number and returns the result",
-      "type": "function",
-      "module": "kotlin.text",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/to-int.html"
-    },
-    "toDouble": {
-      "signature": "fun String.toDouble(): Double",
-      "description": "Parses the string as a Double number and returns the result",
-      "type": "function",
-      "module": "kotlin.text",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/to-double.html"
-    },
-    "toIntOrNull": {
-      "signature": "fun String.toIntOrNull(): Int?",
-      "description": "Parses the string as a signed Int number and returns the result or null if the string is not a valid integer",
-      "type": "function",
-      "module": "kotlin.text",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/to-int-or-null.html"
-    },
-    "runBlocking": {
-      "signature": "fun <T> runBlocking(context: CoroutineContext = EmptyCoroutineContext, block: suspend CoroutineScope.() -> T): T",
-      "description": "Runs a new coroutine and blocks the current thread until its completion",
-      "type": "function",
-      "module": "kotlinx.coroutines",
-      "url": "https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/run-blocking.html"
-    },
-    "launch": {
-      "signature": "fun CoroutineScope.launch(context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> Unit): Job",
-      "description": "Launches a new coroutine without blocking the current thread and returns a reference to it as a Job",
-      "type": "function",
-      "module": "kotlinx.coroutines",
-      "url": "https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/launch.html"
-    },
-    "async": {
-      "signature": "fun <T> CoroutineScope.async(context: CoroutineContext = EmptyCoroutineContext, start: CoroutineStart = CoroutineStart.DEFAULT, block: suspend CoroutineScope.() -> T): Deferred<T>",
-      "description": "Creates a coroutine and returns its future result as an implementation of Deferred",
-      "type": "function",
-      "module": "kotlinx.coroutines",
-      "url": "https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/async.html"
-    },
-    "withContext": {
-      "signature": "suspend fun <T> withContext(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T",
-      "description": "Calls the specified suspending block with a given coroutine context, suspends until it completes, and returns the result",
-      "type": "function",
-      "module": "kotlinx.coroutines",
-      "url": "https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/with-context.html"
-    },
-    "delay": {
-      "signature": "suspend fun delay(timeMillis: Long)",
-      "description": "Delays coroutine for a given time without blocking a thread",
-      "type": "function",
-      "module": "kotlinx.coroutines",
-      "url": "https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines/delay.html"
-    },
-    "fun": {
-      "signature": "fun",
-      "description": "Declares a function",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/functions.html"
-    },
-    "val": {
-      "signature": "val",
-      "description": "Declares a read-only (immutable) property or local variable",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/basic-syntax.html#variables"
-    },
-    "var": {
-      "signature": "var",
-      "description": "Declares a mutable property or local variable",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/basic-syntax.html#variables"
-    },
-    "class": {
-      "signature": "class",
-      "description": "Declares a class",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/classes.html"
-    },
-    "object": {
-      "signature": "object",
-      "description": "Declares a singleton object or object expression",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/object-declarations.html"
-    },
-    "interface": {
-      "signature": "interface",
-      "description": "Declares an interface",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/interfaces.html"
-    },
-    "when": {
-      "signature": "when",
-      "description": "Starts a when expression (replacement for switch)",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/control-flow.html#when-expression"
-    },
-    "if": {
-      "signature": "if",
-      "description": "Conditional expression",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/control-flow.html#if-expression"
-    },
-    "for": {
-      "signature": "for",
-      "description": "For loop that iterates through anything that provides an iterator",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/control-flow.html#for-loops"
-    },
-    "while": {
-      "signature": "while",
-      "description": "While loop that executes body while condition is true",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/control-flow.html#while-loops"
-    },
-    "return": {
-      "signature": "return",
-      "description": "Returns from the nearest enclosing function or anonymous function",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/returns.html"
-    },
-    "throw": {
-      "signature": "throw",
-      "description": "Throws an exception",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/exceptions.html"
-    },
-    "try": {
-      "signature": "try",
-      "description": "Begins a try-catch exception handling block",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/exceptions.html"
-    },
-    "catch": {
-      "signature": "catch",
-      "description": "Handles an exception type in a try block",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/exceptions.html"
-    },
-    "finally": {
-      "signature": "finally",
-      "description": "Block that executes after try/catch regardless of exception",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/exceptions.html"
-    },
-    "suspend": {
-      "signature": "suspend",
-      "description": "Marks a function or lambda as suspending (callable from coroutines)",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/coroutines-basics.html"
-    },
-    "data": {
-      "signature": "data",
-      "description": "Marks a class as a data class, auto-generating equals, hashCode, toString, copy",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/data-classes.html"
-    },
-    "sealed": {
-      "signature": "sealed",
-      "description": "Marks a class or interface as sealed, restricting subclasses to the same package",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/sealed-classes.html"
-    },
-    "enum": {
-      "signature": "enum",
-      "description": "Declares an enum class with a fixed set of instances",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/enum-classes.html"
-    },
-    "override": {
-      "signature": "override",
-      "description": "Marks a member override of a superclass member or interface member",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/inheritance.html#overriding-methods"
-    },
-    "open": {
-      "signature": "open",
-      "description": "Allows a class to be inherited from or a member to be overridden",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/inheritance.html"
-    },
-    "abstract": {
-      "signature": "abstract",
-      "description": "Marks a class or member as abstract",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/classes.html#abstract-classes"
-    },
-    "companion": {
-      "signature": "companion object",
-      "description": "Declares a companion object inside a class",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/object-declarations.html#companion-objects"
-    },
-    "inline": {
-      "signature": "inline",
-      "description": "Requests the compiler to inline the function body and lambda parameters at call sites",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/inline-functions.html"
-    },
-    "infix": {
-      "signature": "infix",
-      "description": "Allows a function to be called with infix notation",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/functions.html#infix-notation"
-    },
-    "operator": {
-      "signature": "operator",
-      "description": "Marks a function as an operator overload",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/operator-overloading.html"
-    },
-    "typealias": {
-      "signature": "typealias",
-      "description": "Provides alternative names for existing types",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/type-aliases.html"
-    },
-    "lateinit": {
-      "signature": "lateinit",
-      "description": "Allows initializing a non-null property outside of a constructor body",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/properties.html#late-initialized-properties-and-variables"
-    },
-    "const": {
-      "signature": "const",
-      "description": "Marks a property as a compile-time constant",
-      "type": "keyword",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/docs/properties.html#compile-time-constants"
-    },
-    "Int": {
-      "signature": "class Int : Number, Comparable<Int>",
-      "description": "Represents a 32-bit signed integer",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/"
-    },
-    "Long": {
-      "signature": "class Long : Number, Comparable<Long>",
-      "description": "Represents a 64-bit signed integer",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/"
-    },
-    "Double": {
-      "signature": "class Double : Number, Comparable<Double>",
-      "description": "Represents a double-precision 64-bit IEEE 754 floating point number",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-double/"
-    },
-    "Float": {
-      "signature": "class Float : Number, Comparable<Float>",
-      "description": "Represents a single-precision 32-bit IEEE 754 floating point number",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-float/"
-    },
-    "Boolean": {
-      "signature": "class Boolean : Comparable<Boolean>",
-      "description": "Represents a value which is either true or false",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/"
-    },
-    "String": {
-      "signature": "class String : Comparable<String>, CharSequence",
-      "description": "Represents an array of characters. Strings are immutable",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-string/"
-    },
-    "Char": {
-      "signature": "class Char : Comparable<Char>",
-      "description": "Represents a 16-bit Unicode character",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-char/"
-    },
-    "Unit": {
-      "signature": "object Unit",
-      "description": "The type with only one value: the Unit object. Corresponds to void in Java",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/"
-    },
-    "Nothing": {
-      "signature": "class Nothing",
-      "description": "Nothing has no instances. Used as return type of functions that never return",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-nothing.html"
-    },
-    "Any": {
-      "signature": "open class Any",
-      "description": "The root of the Kotlin class hierarchy. Every Kotlin class has Any as a superclass",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/"
-    },
-    "Array": {
-      "signature": "class Array<T>",
-      "description": "Represents an array",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-array/"
-    },
-    "List": {
-      "signature": "interface List<out E> : Collection<E>",
-      "description": "A generic ordered collection of elements that supports indexed access",
-      "type": "interface",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-list/"
-    },
-    "MutableList": {
-      "signature": "interface MutableList<E> : List<E>, MutableCollection<E>",
-      "description": "A generic ordered collection of elements that supports adding and removing elements",
-      "type": "interface",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-mutable-list/"
-    },
-    "Map": {
-      "signature": "interface Map<K, out V>",
-      "description": "A collection that holds pairs of objects (keys and values)",
-      "type": "interface",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-map/"
-    },
-    "MutableMap": {
-      "signature": "interface MutableMap<K, V> : Map<K, V>",
-      "description": "A modifiable collection that holds pairs of objects and supports adding and removing entries",
-      "type": "interface",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-mutable-map/"
-    },
-    "Set": {
-      "signature": "interface Set<out E> : Collection<E>",
-      "description": "A generic unordered collection of elements that does not support duplicate elements",
-      "type": "interface",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-set/"
-    },
-    "MutableSet": {
-      "signature": "interface MutableSet<E> : Set<E>, MutableCollection<E>",
-      "description": "A generic unordered collection of elements that does not support duplicate elements and supports adding and removing elements",
-      "type": "interface",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-mutable-set/"
-    },
-    "Pair": {
-      "signature": "data class Pair<out A, out B>(val first: A, val second: B)",
-      "description": "Represents a generic pair of two values",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-pair/"
-    },
-    "Triple": {
-      "signature": "data class Triple<out A, out B, out C>(val first: A, val second: B, val third: C)",
-      "description": "Represents a triad of values",
-      "type": "class",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-triple/"
-    },
-    "Sequence": {
-      "signature": "interface Sequence<out T>",
-      "description": "A sequence that returns values through its iterator, values are evaluated lazily",
-      "type": "interface",
-      "module": "kotlin.sequences",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.sequences/-sequence/"
-    },
-    "Regex": {
-      "signature": "class Regex",
-      "description": "Represents an immutable regular expression",
-      "type": "class",
-      "module": "kotlin.text",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.text/-regex/"
-    },
-    "Comparable": {
-      "signature": "interface Comparable<in T>",
-      "description": "Classes which inherit from this interface have a defined total ordering between their instances",
-      "type": "interface",
-      "module": "kotlin",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-comparable/"
-    },
-    "Iterable": {
-      "signature": "interface Iterable<out T>",
-      "description": "Classes that inherit from this interface can be represented as a sequence of elements that can be iterated over",
-      "type": "interface",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-iterable/"
-    },
-    "Collection": {
-      "signature": "interface Collection<out E> : Iterable<E>",
-      "description": "A generic collection of elements, provides read-only methods",
-      "type": "interface",
-      "module": "kotlin.collections",
-      "url": "https://kotlinlang.org/api/latest/jvm/stdlib/kotlin.collections/-collection/"
-    }
-  }
-}
+{
+  "language": "kotlin",
+  "definitions": {
+    "String": {
+      "signature": "class String : Comparable<String>, CharSequence",
+      "description": "An immutable sequence of UTF-16 characters representing text. Kotlin strings support template expressions via $variable and ${expression} syntax, raw strings using triple quotes, and a rich set of extension functions for searching, transforming, and formatting text content.",
+      "type": "class",
+      "module": "kotlin",
+      "members": {
+        "length": {
+          "signature": "val length: Int",
+          "description": "Returns the number of characters in this string.",
+          "type": "property"
+        },
+        "substring": {
+          "signature": "fun substring(startIndex: Int, endIndex: Int = length): String",
+          "description": "Returns a substring starting at startIndex and ending before endIndex.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "fun split(vararg delimiters: String, ignoreCase: Boolean = false, limit: Int = 0): List<String>",
+          "description": "Splits the string around matches of the given delimiters and returns a list of substrings.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "fun replace(oldValue: String, newValue: String, ignoreCase: Boolean = false): String",
+          "description": "Returns a new string with all occurrences of oldValue replaced with newValue.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "fun trim(): String",
+          "description": "Returns a string with leading and trailing whitespace removed.",
+          "type": "method"
+        },
+        "toIntOrNull": {
+          "signature": "fun String.toIntOrNull(radix: Int = 10): Int?",
+          "description": "Parses the string as an integer in the given radix, returning null if the string is not a valid integer.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "fun contains(other: CharSequence, ignoreCase: Boolean = false): Boolean",
+          "description": "Returns true if this string contains the specified other sequence of characters.",
+          "type": "method"
+        }
+      }
+    },
+    "List": {
+      "signature": "interface List<out E> : Collection<E>",
+      "description": "An ordered, read-only collection of elements that supports indexed access. Lists are one of the most commonly used collection types in Kotlin, created via listOf() for immutable or mutableListOf() for mutable variants, and support rich functional operations via extension functions.",
+      "type": "class",
+      "module": "kotlin.collections",
+      "members": {
+        "get": {
+          "signature": "operator fun get(index: Int): E",
+          "description": "Returns the element at the specified index, throwing IndexOutOfBoundsException if out of range.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "val size: Int",
+          "description": "Returns the number of elements in the list.",
+          "type": "property"
+        },
+        "contains": {
+          "signature": "fun contains(element: E): Boolean",
+          "description": "Checks if the list contains the specified element using equals comparison.",
+          "type": "method"
+        },
+        "indexOf": {
+          "signature": "fun indexOf(element: E): Int",
+          "description": "Returns the index of the first occurrence of the element, or -1 if not found.",
+          "type": "method"
+        },
+        "filter": {
+          "signature": "fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>",
+          "description": "Returns a list containing only elements matching the given predicate function.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>",
+          "description": "Returns a list containing the results of applying the transform function to each element.",
+          "type": "method"
+        },
+        "sortedBy": {
+          "signature": "fun <T, R : Comparable<R>> Iterable<T>.sortedBy(selector: (T) -> R?): List<T>",
+          "description": "Returns a list of all elements sorted by the value returned by the selector function.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "fun <T> List<T>.first(): T",
+          "description": "Returns the first element, throwing NoSuchElementException if the list is empty.",
+          "type": "method"
+        }
+      }
+    },
+    "Map": {
+      "signature": "interface Map<K, out V>",
+      "description": "A read-only collection of key-value pairs where each key is unique. Created via mapOf() for immutable or mutableMapOf() for mutable maps. Kotlin maps support destructuring declarations, filtering, mapping, and efficient key-based lookup.",
+      "type": "class",
+      "module": "kotlin.collections",
+      "members": {
+        "get": {
+          "signature": "operator fun get(key: K): V?",
+          "description": "Returns the value for the given key, or null if no such key exists in the map.",
+          "type": "method"
+        },
+        "keys": {
+          "signature": "val keys: Set<K>",
+          "description": "Returns a read-only set of all keys in this map.",
+          "type": "property"
+        },
+        "values": {
+          "signature": "val values: Collection<V>",
+          "description": "Returns a read-only collection of all values in this map.",
+          "type": "property"
+        },
+        "entries": {
+          "signature": "val entries: Set<Map.Entry<K, V>>",
+          "description": "Returns a read-only set of all key-value pairs in this map.",
+          "type": "property"
+        },
+        "containsKey": {
+          "signature": "fun containsKey(key: K): Boolean",
+          "description": "Returns true if the map contains the specified key.",
+          "type": "method"
+        },
+        "getOrDefault": {
+          "signature": "fun getOrDefault(key: K, defaultValue: V): V",
+          "description": "Returns the value for the given key, or the defaultValue if no mapping exists.",
+          "type": "method"
+        }
+      }
+    },
+    "Set": {
+      "signature": "interface Set<out E> : Collection<E>",
+      "description": "A read-only collection of unique elements with no defined ordering guarantee. Created via setOf() for immutable or mutableSetOf() for mutable variants. Supports set-theoretic operations like union, intersect, and subtract via extension functions.",
+      "type": "class",
+      "module": "kotlin.collections",
+      "members": {
+        "contains": {
+          "signature": "fun contains(element: E): Boolean",
+          "description": "Checks if the set contains the specified element.",
+          "type": "method"
+        },
+        "size": {
+          "signature": "val size: Int",
+          "description": "Returns the number of elements in the set.",
+          "type": "property"
+        },
+        "union": {
+          "signature": "infix fun <T> Set<T>.union(other: Iterable<T>): Set<T>",
+          "description": "Returns a set containing all elements from both this set and the other collection.",
+          "type": "method"
+        },
+        "intersect": {
+          "signature": "infix fun <T> Set<T>.intersect(other: Iterable<T>): Set<T>",
+          "description": "Returns a set containing only elements present in both this set and the other collection.",
+          "type": "method"
+        },
+        "subtract": {
+          "signature": "infix fun <T> Set<T>.subtract(other: Iterable<T>): Set<T>",
+          "description": "Returns a set containing elements in this set but not in the other collection.",
+          "type": "method"
+        }
+      }
+    },
+    "Sequence": {
+      "signature": "interface Sequence<out T>",
+      "description": "A lazily evaluated collection that computes elements on demand during iteration. Unlike eager List operations, Sequence chains intermediate operations without creating temporary collections, making it efficient for large data sets or expensive transformations. Created via sequenceOf(), generateSequence(), or the .asSequence() extension.",
+      "type": "class",
+      "module": "kotlin.sequences",
+      "members": {
+        "filter": {
+          "signature": "fun <T> Sequence<T>.filter(predicate: (T) -> Boolean): Sequence<T>",
+          "description": "Returns a sequence containing only elements matching the given predicate (lazy evaluation).",
+          "type": "method"
+        },
+        "map": {
+          "signature": "fun <T, R> Sequence<T>.map(transform: (T) -> R): Sequence<R>",
+          "description": "Returns a sequence that applies the transform function lazily to each element.",
+          "type": "method"
+        },
+        "take": {
+          "signature": "fun <T> Sequence<T>.take(n: Int): Sequence<T>",
+          "description": "Returns a sequence containing only the first n elements.",
+          "type": "method"
+        },
+        "toList": {
+          "signature": "fun <T> Sequence<T>.toList(): List<T>",
+          "description": "Returns a List containing all elements of this sequence, triggering terminal evaluation.",
+          "type": "method"
+        }
+      }
+    },
+    "Pair": {
+      "signature": "data class Pair<out A, out B>(val first: A, val second: B)",
+      "description": "A generic data class representing a pair of two values. Created using the infix function to (e.g., 1 to \"one\"). Commonly used for map entries, returning two values from a function, and destructuring declarations via (a, b) = pair syntax.",
+      "type": "class",
+      "module": "kotlin",
+      "members": {
+        "first": {
+          "signature": "val first: A",
+          "description": "The first element of the pair.",
+          "type": "property"
+        },
+        "second": {
+          "signature": "val second: B",
+          "description": "The second element of the pair.",
+          "type": "property"
+        },
+        "toList": {
+          "signature": "fun toList(): List<Any?>",
+          "description": "Converts this pair into a list containing the first and second elements.",
+          "type": "method"
+        }
+      }
+    },
+    "Regex": {
+      "signature": "class Regex(pattern: String, options: Set<RegexOption> = emptySet())",
+      "description": "Represents a compiled regular expression pattern used for matching, finding, and replacing text. Supports named groups, regex options like IGNORE_CASE and MULTILINE, and provides Kotlin-idiomatic APIs for pattern operations that integrate cleanly with string extension functions.",
+      "type": "class",
+      "module": "kotlin.text",
+      "members": {
+        "find": {
+          "signature": "fun find(input: CharSequence, startIndex: Int = 0): MatchResult?",
+          "description": "Returns the first match of the regular expression in the input, starting at startIndex, or null if not found.",
+          "type": "method"
+        },
+        "findAll": {
+          "signature": "fun findAll(input: CharSequence, startIndex: Int = 0): Sequence<MatchResult>",
+          "description": "Returns a lazy sequence of all non-overlapping matches of the pattern in the input string.",
+          "type": "method"
+        },
+        "matches": {
+          "signature": "fun matches(input: CharSequence): Boolean",
+          "description": "Returns true if the entire input string matches this regular expression pattern.",
+          "type": "method"
+        },
+        "replace": {
+          "signature": "fun replace(input: CharSequence, replacement: String): String",
+          "description": "Replaces all occurrences of the pattern in the input with the replacement string.",
+          "type": "method"
+        },
+        "containsMatchIn": {
+          "signature": "fun containsMatchIn(input: CharSequence): Boolean",
+          "description": "Returns true if there is at least one match of this pattern anywhere in the input string.",
+          "type": "method"
+        }
+      }
+    },
+    "println": {
+      "signature": "fun println(message: Any?)",
+      "description": "Prints the given message to the standard output stream followed by a newline character. Accepts any nullable type, converting it to a string representation via toString(). This is the primary function for console output in Kotlin programs.",
+      "type": "function",
+      "module": "kotlin.io"
+    },
+    "listOf": {
+      "signature": "fun <T> listOf(vararg elements: T): List<T>",
+      "description": "Creates an immutable list containing the specified elements in the order they are provided. The returned list does not support add or remove operations. Use mutableListOf() when mutation is needed. This is the idiomatic Kotlin way to create read-only lists.",
+      "type": "function",
+      "module": "kotlin.collections"
+    },
+    "data class": {
+      "signature": "data class Name(val prop1: Type1, val prop2: Type2, ...)",
+      "description": "Declares a class whose primary purpose is holding data, automatically generating equals(), hashCode(), toString(), copy(), and componentN() destructuring functions from the primary constructor parameters. Data classes must have at least one val or var parameter and cannot be abstract, open, sealed, or inner.",
+      "type": "keyword",
+      "module": "kotlin"
+    }
+  }
+}