@enjoys/context-engine 1.1.0 → 1.1.2

package/data/completion/kotlin.json

@@ -0,0 +1,1580 @@
+{
+  "language": "kotlin",
+  "completions": [
+    {
+      "label": "fun",
+      "kind": 17,
+      "detail": "Function declaration keyword",
+      "documentation": {"value": "```kotlin\nfun name(params): ReturnType {\n    // body\n}\n```\nDeclares a function."},
+      "insertText": "fun ${1:name}(${2:params}): ${3:Unit} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_fun"
+    },
+    {
+      "label": "val",
+      "kind": 17,
+      "detail": "Immutable variable declaration",
+      "documentation": {"value": "```kotlin\nval name: Type = value\n```\nDeclares a read-only (immutable) variable."},
+      "insertText": "val ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_val"
+    },
+    {
+      "label": "var",
+      "kind": 17,
+      "detail": "Mutable variable declaration",
+      "documentation": {"value": "```kotlin\nvar name: Type = value\n```\nDeclares a mutable variable."},
+      "insertText": "var ${1:name}: ${2:Type} = ${3:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_var"
+    },
+    {
+      "label": "class",
+      "kind": 17,
+      "detail": "Class declaration keyword",
+      "documentation": {"value": "```kotlin\nclass Name(params) {\n    // body\n}\n```\nDeclares a class."},
+      "insertText": "class ${1:Name}(${2:params}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_class"
+    },
+    {
+      "label": "object",
+      "kind": 17,
+      "detail": "Object declaration keyword",
+      "documentation": {"value": "```kotlin\nobject Name {\n    // singleton body\n}\n```\nDeclares a singleton object."},
+      "insertText": "object ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_object"
+    },
+    {
+      "label": "interface",
+      "kind": 17,
+      "detail": "Interface declaration keyword",
+      "documentation": {"value": "```kotlin\ninterface Name {\n    fun method()\n}\n```\nDeclares an interface."},
+      "insertText": "interface ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_interface"
+    },
+    {
+      "label": "enum",
+      "kind": 17,
+      "detail": "Enum class keyword",
+      "documentation": {"value": "```kotlin\nenum class Name {\n    VALUE1, VALUE2\n}\n```\nDeclares an enum class."},
+      "insertText": "enum class ${1:Name} {\n\t${2:VALUE1},\n\t${3:VALUE2}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_enum"
+    },
+    {
+      "label": "sealed",
+      "kind": 17,
+      "detail": "Sealed class/interface keyword",
+      "documentation": {"value": "```kotlin\nsealed class Result {\n    data class Success(val data: String) : Result()\n    data class Error(val msg: String) : Result()\n}\n```\nDeclares a sealed class."},
+      "insertText": "sealed class ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_sealed"
+    },
+    {
+      "label": "data",
+      "kind": 17,
+      "detail": "Data class modifier",
+      "documentation": {"value": "```kotlin\ndata class Name(val prop: Type)\n```\nA class primarily used to hold data. Automatically generates equals(), hashCode(), toString(), copy(), and componentN()."},
+      "insertText": "data class ${1:Name}(\n\tval ${2:property}: ${3:Type}\n)",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_data"
+    },
+    {
+      "label": "abstract",
+      "kind": 17,
+      "detail": "Abstract modifier keyword",
+      "documentation": {"value": "```kotlin\nabstract class Name {\n    abstract fun method()\n}\n```\nMarks a class or member as abstract."},
+      "insertText": "abstract",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_abstract"
+    },
+    {
+      "label": "open",
+      "kind": 17,
+      "detail": "Open modifier keyword",
+      "documentation": {"value": "Marks a class or member as open for inheritance/overriding. Classes in Kotlin are final by default."},
+      "insertText": "open",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_open"
+    },
+    {
+      "label": "override",
+      "kind": 17,
+      "detail": "Override modifier keyword",
+      "documentation": {"value": "Marks a member as overriding a superclass or interface member."},
+      "insertText": "override",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_override"
+    },
+    {
+      "label": "companion",
+      "kind": 17,
+      "detail": "Companion object keyword",
+      "documentation": {"value": "```kotlin\ncompanion object {\n    const val CONSTANT = \"value\"\n}\n```\nDeclares a companion object inside a class."},
+      "insertText": "companion object {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_companion"
+    },
+    {
+      "label": "init",
+      "kind": 17,
+      "detail": "Initializer block keyword",
+      "documentation": {"value": "```kotlin\ninit {\n    // initialization code\n}\n```\nDeclares an initializer block."},
+      "insertText": "init {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_init"
+    },
+    {
+      "label": "constructor",
+      "kind": 17,
+      "detail": "Secondary constructor keyword",
+      "documentation": {"value": "```kotlin\nconstructor(params) : this(args) {\n    // body\n}\n```\nDeclares a secondary constructor."},
+      "insertText": "constructor(${1:params}) : this(${2:args}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_constructor"
+    },
+    {
+      "label": "when",
+      "kind": 17,
+      "detail": "When expression keyword",
+      "documentation": {"value": "```kotlin\nwhen (value) {\n    condition -> result\n    else -> default\n}\n```\nPattern matching expression, replacement for switch."},
+      "insertText": "when (${1:value}) {\n\t${2:condition} -> ${3:result}\n\telse -> ${4:default}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_when"
+    },
+    {
+      "label": "if",
+      "kind": 17,
+      "detail": "Conditional keyword",
+      "documentation": {"value": "```kotlin\nif (condition) {\n    // then\n} else {\n    // else\n}\n```\nConditional expression."},
+      "insertText": "if (${1:condition}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_if"
+    },
+    {
+      "label": "else",
+      "kind": 17,
+      "detail": "Else branch keyword",
+      "documentation": {"value": "Alternative branch in an if expression."},
+      "insertText": "else {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_else"
+    },
+    {
+      "label": "for",
+      "kind": 17,
+      "detail": "For loop keyword",
+      "documentation": {"value": "```kotlin\nfor (item in collection) {\n    // body\n}\n```\nIterates over a range, array, or collection."},
+      "insertText": "for (${1:item} in ${2:collection}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_for"
+    },
+    {
+      "label": "while",
+      "kind": 17,
+      "detail": "While loop keyword",
+      "documentation": {"value": "```kotlin\nwhile (condition) {\n    // body\n}\n```\nRepeats while condition is true."},
+      "insertText": "while (${1:condition}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_while"
+    },
+    {
+      "label": "do",
+      "kind": 17,
+      "detail": "Do-while loop keyword",
+      "documentation": {"value": "```kotlin\ndo {\n    // body\n} while (condition)\n```\nExecutes body at least once, then repeats while condition is true."},
+      "insertText": "do {\n\t$0\n} while (${1:condition})",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_do"
+    },
+    {
+      "label": "return",
+      "kind": 17,
+      "detail": "Return keyword",
+      "documentation": {"value": "Returns a value from a function. Can use labels for non-local returns."},
+      "insertText": "return ${1:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_return"
+    },
+    {
+      "label": "break",
+      "kind": 17,
+      "detail": "Break keyword",
+      "documentation": {"value": "Terminates the nearest enclosing loop."},
+      "insertText": "break",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_break"
+    },
+    {
+      "label": "continue",
+      "kind": 17,
+      "detail": "Continue keyword",
+      "documentation": {"value": "Proceeds to the next step of the nearest enclosing loop."},
+      "insertText": "continue",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_continue"
+    },
+    {
+      "label": "throw",
+      "kind": 17,
+      "detail": "Throw exception keyword",
+      "documentation": {"value": "```kotlin\nthrow Exception(\"message\")\n```\nThrows an exception."},
+      "insertText": "throw ${1:Exception}(\"${2:message}\")",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_throw"
+    },
+    {
+      "label": "try",
+      "kind": 17,
+      "detail": "Try-catch keyword",
+      "documentation": {"value": "```kotlin\ntry {\n    // code\n} catch (e: Exception) {\n    // handle\n} finally {\n    // cleanup\n}\n```\nBegins an exception handling block."},
+      "insertText": "try {\n\t${1:// code}\n} catch (e: ${2:Exception}) {\n\t${3:e.printStackTrace()}\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_try"
+    },
+    {
+      "label": "catch",
+      "kind": 17,
+      "detail": "Catch block keyword",
+      "documentation": {"value": "Catches exceptions thrown in a try block."},
+      "insertText": "catch (e: ${1:Exception}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_catch"
+    },
+    {
+      "label": "finally",
+      "kind": 17,
+      "detail": "Finally block keyword",
+      "documentation": {"value": "Block that always executes after try/catch, regardless of outcome."},
+      "insertText": "finally {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_finally"
+    },
+    {
+      "label": "is",
+      "kind": 17,
+      "detail": "Type check operator",
+      "documentation": {"value": "Checks whether an object is of a given type. Smart cast applies after the check."},
+      "insertText": "is ${1:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_is"
+    },
+    {
+      "label": "as",
+      "kind": 17,
+      "detail": "Type cast operator",
+      "documentation": {"value": "Unsafe type cast. Use `as?` for safe cast that returns null on failure."},
+      "insertText": "as ${1:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_as"
+    },
+    {
+      "label": "in",
+      "kind": 17,
+      "detail": "In operator keyword",
+      "documentation": {"value": "Used in for loops and to check containment."},
+      "insertText": "in",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_in"
+    },
+    {
+      "label": "out",
+      "kind": 17,
+      "detail": "Variance annotation (covariant)",
+      "documentation": {"value": "Marks a type parameter as covariant (producer)."},
+      "insertText": "out",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_out"
+    },
+    {
+      "label": "by",
+      "kind": 17,
+      "detail": "Delegation keyword",
+      "documentation": {"value": "Used for class delegation or delegated properties."},
+      "insertText": "by",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_by"
+    },
+    {
+      "label": "where",
+      "kind": 17,
+      "detail": "Generic constraint keyword",
+      "documentation": {"value": "Specifies upper bound constraints for generic type parameters."},
+      "insertText": "where ${1:T} : ${2:Bound}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_where"
+    },
+    {
+      "label": "suspend",
+      "kind": 17,
+      "detail": "Suspend function modifier",
+      "documentation": {"value": "Marks a function as suspendable for use in coroutines."},
+      "insertText": "suspend",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_suspend"
+    },
+    {
+      "label": "inline",
+      "kind": 17,
+      "detail": "Inline function modifier",
+      "documentation": {"value": "Requests the compiler to inline the function and its lambda parameters at call sites."},
+      "insertText": "inline",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_inline"
+    },
+    {
+      "label": "infix",
+      "kind": 17,
+      "detail": "Infix function modifier",
+      "documentation": {"value": "Allows calling a function with infix notation (without dot and parentheses)."},
+      "insertText": "infix",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_infix"
+    },
+    {
+      "label": "operator",
+      "kind": 17,
+      "detail": "Operator overload modifier",
+      "documentation": {"value": "Marks a function as an operator overload."},
+      "insertText": "operator",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_operator"
+    },
+    {
+      "label": "tailrec",
+      "kind": 17,
+      "detail": "Tail recursive modifier",
+      "documentation": {"value": "Marks a function as tail-recursive, enabling compiler optimization."},
+      "insertText": "tailrec",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_tailrec"
+    },
+    {
+      "label": "external",
+      "kind": 17,
+      "detail": "External declaration modifier",
+      "documentation": {"value": "Marks a declaration as implemented externally (e.g., in native code)."},
+      "insertText": "external",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_external"
+    },
+    {
+      "label": "annotation",
+      "kind": 17,
+      "detail": "Annotation class keyword",
+      "documentation": {"value": "```kotlin\nannotation class MyAnnotation\n```\nDeclares an annotation class."},
+      "insertText": "annotation class ${1:Name}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_annotation"
+    },
+    {
+      "label": "crossinline",
+      "kind": 17,
+      "detail": "Crossinline modifier",
+      "documentation": {"value": "Forbids non-local returns in a lambda passed to an inline function."},
+      "insertText": "crossinline",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_crossinline"
+    },
+    {
+      "label": "noinline",
+      "kind": 17,
+      "detail": "Noinline modifier",
+      "documentation": {"value": "Prevents inlining of a lambda parameter in an inline function."},
+      "insertText": "noinline",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_noinline"
+    },
+    {
+      "label": "reified",
+      "kind": 17,
+      "detail": "Reified type parameter modifier",
+      "documentation": {"value": "Makes a type parameter of an inline function available at runtime."},
+      "insertText": "reified",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_reified"
+    },
+    {
+      "label": "vararg",
+      "kind": 17,
+      "detail": "Variable arguments modifier",
+      "documentation": {"value": "Allows passing a variable number of arguments to a function parameter."},
+      "insertText": "vararg ${1:name}: ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_vararg"
+    },
+    {
+      "label": "typealias",
+      "kind": 17,
+      "detail": "Type alias declaration",
+      "documentation": {"value": "```kotlin\ntypealias Name = ExistingType\n```\nCreates an alias for an existing type."},
+      "insertText": "typealias ${1:Name} = ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_typealias"
+    },
+    {
+      "label": "import",
+      "kind": 17,
+      "detail": "Import declaration",
+      "documentation": {"value": "Imports a class, function, or property from another package."},
+      "insertText": "import ${1:package.name}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_import"
+    },
+    {
+      "label": "package",
+      "kind": 17,
+      "detail": "Package declaration",
+      "documentation": {"value": "Declares the package of the current file."},
+      "insertText": "package ${1:com.example}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_package"
+    },
+    {
+      "label": "private",
+      "kind": 17,
+      "detail": "Private visibility modifier",
+      "documentation": {"value": "Visible only inside the file or class containing the declaration."},
+      "insertText": "private",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_private"
+    },
+    {
+      "label": "protected",
+      "kind": 17,
+      "detail": "Protected visibility modifier",
+      "documentation": {"value": "Visible in the class and its subclasses."},
+      "insertText": "protected",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_protected"
+    },
+    {
+      "label": "internal",
+      "kind": 17,
+      "detail": "Internal visibility modifier",
+      "documentation": {"value": "Visible within the same module."},
+      "insertText": "internal",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_internal"
+    },
+    {
+      "label": "public",
+      "kind": 17,
+      "detail": "Public visibility modifier",
+      "documentation": {"value": "Visible everywhere. This is the default visibility in Kotlin."},
+      "insertText": "public",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_public"
+    },
+    {
+      "label": "lateinit",
+      "kind": 17,
+      "detail": "Late initialization modifier",
+      "documentation": {"value": "Allows initializing a non-null property outside of a constructor."},
+      "insertText": "lateinit var ${1:name}: ${2:Type}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_lateinit"
+    },
+    {
+      "label": "const",
+      "kind": 17,
+      "detail": "Compile-time constant modifier",
+      "documentation": {"value": "Marks a property as a compile-time constant. Must be a top-level or companion object val of primitive or String type."},
+      "insertText": "const val ${1:NAME} = ${2:value}",
+      "insertTextRules": 4,
+      "sortText": "01_keyword_const"
+    },
+    {
+      "label": "expect",
+      "kind": 17,
+      "detail": "Multiplatform expect keyword",
+      "documentation": {"value": "Declares a platform-specific API expected to be implemented in actual modules."},
+      "insertText": "expect",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_expect"
+    },
+    {
+      "label": "actual",
+      "kind": 17,
+      "detail": "Multiplatform actual keyword",
+      "documentation": {"value": "Provides the platform-specific implementation for an expect declaration."},
+      "insertText": "actual",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_actual"
+    },
+    {
+      "label": "this",
+      "kind": 17,
+      "detail": "Current instance reference",
+      "documentation": {"value": "Refers to the current receiver."},
+      "insertText": "this",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_this"
+    },
+    {
+      "label": "super",
+      "kind": 17,
+      "detail": "Superclass reference",
+      "documentation": {"value": "Refers to the superclass implementation."},
+      "insertText": "super",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_super"
+    },
+    {
+      "label": "null",
+      "kind": 17,
+      "detail": "Null literal",
+      "documentation": {"value": "Represents the null reference."},
+      "insertText": "null",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_null"
+    },
+    {
+      "label": "true",
+      "kind": 17,
+      "detail": "Boolean true literal",
+      "documentation": {"value": "Boolean true value."},
+      "insertText": "true",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_true"
+    },
+    {
+      "label": "false",
+      "kind": 17,
+      "detail": "Boolean false literal",
+      "documentation": {"value": "Boolean false value."},
+      "insertText": "false",
+      "insertTextRules": 0,
+      "sortText": "01_keyword_false"
+    },
+    {
+      "label": "println",
+      "kind": 1,
+      "detail": "fun println(message: Any?): Unit",
+      "documentation": {"value": "```kotlin\nfun println(message: Any?): Unit\n```\nPrints the given message and a newline to standard output."},
+      "insertText": "println(${1:message})",
+      "insertTextRules": 4,
+      "sortText": "02_function_println"
+    },
+    {
+      "label": "print",
+      "kind": 1,
+      "detail": "fun print(message: Any?): Unit",
+      "documentation": {"value": "```kotlin\nfun print(message: Any?): Unit\n```\nPrints the given message to standard output without a newline."},
+      "insertText": "print(${1:message})",
+      "insertTextRules": 4,
+      "sortText": "02_function_print"
+    },
+    {
+      "label": "readLine",
+      "kind": 1,
+      "detail": "fun readLine(): String?",
+      "documentation": {"value": "```kotlin\nfun readLine(): String?\n```\nReads a line from standard input. Returns null if EOF."},
+      "insertText": "readLine()",
+      "insertTextRules": 0,
+      "sortText": "02_function_readLine"
+    },
+    {
+      "label": "listOf",
+      "kind": 1,
+      "detail": "fun <T> listOf(vararg elements: T): List<T>",
+      "documentation": {"value": "```kotlin\nfun <T> listOf(vararg elements: T): List<T>\n```\nReturns a new read-only list of given elements."},
+      "insertText": "listOf(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_function_listOf"
+    },
+    {
+      "label": "mutableListOf",
+      "kind": 1,
+      "detail": "fun <T> mutableListOf(vararg elements: T): MutableList<T>",
+      "documentation": {"value": "```kotlin\nfun <T> mutableListOf(vararg elements: T): MutableList<T>\n```\nReturns a new MutableList with the given elements."},
+      "insertText": "mutableListOf(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_function_mutableListOf"
+    },
+    {
+      "label": "mapOf",
+      "kind": 1,
+      "detail": "fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>",
+      "documentation": {"value": "```kotlin\nfun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>\n```\nReturns a new read-only map of given key-value pairs."},
+      "insertText": "mapOf(${1:key} to ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "02_function_mapOf"
+    },
+    {
+      "label": "mutableMapOf",
+      "kind": 1,
+      "detail": "fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>",
+      "documentation": {"value": "```kotlin\nfun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>\n```\nReturns a new MutableMap with the given key-value pairs."},
+      "insertText": "mutableMapOf(${1:key} to ${2:value})",
+      "insertTextRules": 4,
+      "sortText": "02_function_mutableMapOf"
+    },
+    {
+      "label": "setOf",
+      "kind": 1,
+      "detail": "fun <T> setOf(vararg elements: T): Set<T>",
+      "documentation": {"value": "```kotlin\nfun <T> setOf(vararg elements: T): Set<T>\n```\nReturns a new read-only set of given elements."},
+      "insertText": "setOf(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_function_setOf"
+    },
+    {
+      "label": "mutableSetOf",
+      "kind": 1,
+      "detail": "fun <T> mutableSetOf(vararg elements: T): MutableSet<T>",
+      "documentation": {"value": "```kotlin\nfun <T> mutableSetOf(vararg elements: T): MutableSet<T>\n```\nReturns a new MutableSet with the given elements."},
+      "insertText": "mutableSetOf(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_function_mutableSetOf"
+    },
+    {
+      "label": "arrayOf",
+      "kind": 1,
+      "detail": "fun <T> arrayOf(vararg elements: T): Array<T>",
+      "documentation": {"value": "```kotlin\nfun <T> arrayOf(vararg elements: T): Array<T>\n```\nReturns an array of given elements."},
+      "insertText": "arrayOf(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_function_arrayOf"
+    },
+    {
+      "label": "intArrayOf",
+      "kind": 1,
+      "detail": "fun intArrayOf(vararg elements: Int): IntArray",
+      "documentation": {"value": "```kotlin\nfun intArrayOf(vararg elements: Int): IntArray\n```\nReturns an IntArray of given elements."},
+      "insertText": "intArrayOf(${1:elements})",
+      "insertTextRules": 4,
+      "sortText": "02_function_intArrayOf"
+    },
+    {
+      "label": "let",
+      "kind": 1,
+      "detail": "fun <T, R> T.let(block: (T) -> R): R",
+      "documentation": {"value": "```kotlin\nfun <T, R> T.let(block: (T) -> R): R\n```\nCalls the specified function block with `this` value as argument and returns its result. Often used for null checks."},
+      "insertText": "let { ${1:it} ->\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_let"
+    },
+    {
+      "label": "run",
+      "kind": 1,
+      "detail": "fun <T, R> T.run(block: T.() -> R): R",
+      "documentation": {"value": "```kotlin\nfun <T, R> T.run(block: T.() -> R): R\n```\nCalls the specified function block with `this` as receiver and returns its result."},
+      "insertText": "run {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_run"
+    },
+    {
+      "label": "with",
+      "kind": 1,
+      "detail": "fun <T, R> with(receiver: T, block: T.() -> R): R",
+      "documentation": {"value": "```kotlin\nfun <T, R> with(receiver: T, block: T.() -> R): R\n```\nCalls the specified function block with the given receiver as `this` and returns its result."},
+      "insertText": "with(${1:receiver}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_with"
+    },
+    {
+      "label": "apply",
+      "kind": 1,
+      "detail": "fun <T> T.apply(block: T.() -> Unit): T",
+      "documentation": {"value": "```kotlin\nfun <T> T.apply(block: T.() -> Unit): T\n```\nCalls the specified function block with `this` as receiver and returns `this`. Used for object configuration."},
+      "insertText": "apply {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_apply"
+    },
+    {
+      "label": "also",
+      "kind": 1,
+      "detail": "fun <T> T.also(block: (T) -> Unit): T",
+      "documentation": {"value": "```kotlin\nfun <T> T.also(block: (T) -> Unit): T\n```\nCalls the specified function block with `this` as argument and returns `this`. Used for side effects."},
+      "insertText": "also { ${1:it} ->\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_also"
+    },
+    {
+      "label": "takeIf",
+      "kind": 1,
+      "detail": "fun <T> T.takeIf(predicate: (T) -> Boolean): T?",
+      "documentation": {"value": "```kotlin\nfun <T> T.takeIf(predicate: (T) -> Boolean): T?\n```\nReturns `this` if it satisfies the predicate, otherwise null."},
+      "insertText": "takeIf { ${1:condition} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_takeIf"
+    },
+    {
+      "label": "takeUnless",
+      "kind": 1,
+      "detail": "fun <T> T.takeUnless(predicate: (T) -> Boolean): T?",
+      "documentation": {"value": "```kotlin\nfun <T> T.takeUnless(predicate: (T) -> Boolean): T?\n```\nReturns `this` if it does NOT satisfy the predicate, otherwise null."},
+      "insertText": "takeUnless { ${1:condition} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_takeUnless"
+    },
+    {
+      "label": "repeat",
+      "kind": 1,
+      "detail": "fun repeat(times: Int, action: (Int) -> Unit)",
+      "documentation": {"value": "```kotlin\nfun repeat(times: Int, action: (Int) -> Unit)\n```\nExecutes the given action the specified number of times."},
+      "insertText": "repeat(${1:times}) { ${2:index} ->\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_repeat"
+    },
+    {
+      "label": "require",
+      "kind": 1,
+      "detail": "fun require(value: Boolean, lazyMessage: () -> Any): Unit",
+      "documentation": {"value": "```kotlin\nfun require(value: Boolean, lazyMessage: () -> Any): Unit\n```\nThrows IllegalArgumentException if the value is false."},
+      "insertText": "require(${1:condition}) { \"${2:message}\" }",
+      "insertTextRules": 4,
+      "sortText": "02_function_require"
+    },
+    {
+      "label": "check",
+      "kind": 1,
+      "detail": "fun check(value: Boolean, lazyMessage: () -> Any): Unit",
+      "documentation": {"value": "```kotlin\nfun check(value: Boolean, lazyMessage: () -> Any): Unit\n```\nThrows IllegalStateException if the value is false."},
+      "insertText": "check(${1:condition}) { \"${2:message}\" }",
+      "insertTextRules": 4,
+      "sortText": "02_function_check"
+    },
+    {
+      "label": "error",
+      "kind": 1,
+      "detail": "fun error(message: Any): Nothing",
+      "documentation": {"value": "```kotlin\nfun error(message: Any): Nothing\n```\nThrows an IllegalStateException with the given message."},
+      "insertText": "error(\"${1:message}\")",
+      "insertTextRules": 4,
+      "sortText": "02_function_error"
+    },
+    {
+      "label": "TODO",
+      "kind": 1,
+      "detail": "fun TODO(reason: String): Nothing",
+      "documentation": {"value": "```kotlin\nfun TODO(reason: String): Nothing\n```\nAlways throws NotImplementedError with an optional reason."},
+      "insertText": "TODO(\"${1:reason}\")",
+      "insertTextRules": 4,
+      "sortText": "02_function_TODO"
+    },
+    {
+      "label": "lazy",
+      "kind": 1,
+      "detail": "fun <T> lazy(initializer: () -> T): Lazy<T>",
+      "documentation": {"value": "```kotlin\nfun <T> lazy(initializer: () -> T): Lazy<T>\n```\nCreates a lazily initialized value. Computed on first access."},
+      "insertText": "lazy { ${1:value} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_lazy"
+    },
+    {
+      "label": "sequence",
+      "kind": 1,
+      "detail": "fun <T> sequence(block: suspend SequenceScope<T>.() -> Unit): Sequence<T>",
+      "documentation": {"value": "```kotlin\nfun <T> sequence(block: suspend SequenceScope<T>.() -> Unit): Sequence<T>\n```\nBuilds a Sequence lazily yielding values one by one."},
+      "insertText": "sequence {\n\tyield(${1:value})\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_sequence"
+    },
+    {
+      "label": "buildList",
+      "kind": 1,
+      "detail": "fun <E> buildList(builderAction: MutableList<E>.() -> Unit): List<E>",
+      "documentation": {"value": "```kotlin\nfun <E> buildList(builderAction: MutableList<E>.() -> Unit): List<E>\n```\nBuilds a new read-only List by populating a MutableList."},
+      "insertText": "buildList {\n\tadd(${1:element})\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_buildList"
+    },
+    {
+      "label": "buildMap",
+      "kind": 1,
+      "detail": "fun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>",
+      "documentation": {"value": "```kotlin\nfun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>\n```\nBuilds a new read-only Map by populating a MutableMap."},
+      "insertText": "buildMap {\n\tput(${1:key}, ${2:value})\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_buildMap"
+    },
+    {
+      "label": "buildSet",
+      "kind": 1,
+      "detail": "fun <E> buildSet(builderAction: MutableSet<E>.() -> Unit): Set<E>",
+      "documentation": {"value": "```kotlin\nfun <E> buildSet(builderAction: MutableSet<E>.() -> Unit): Set<E>\n```\nBuilds a new read-only Set by populating a MutableSet."},
+      "insertText": "buildSet {\n\tadd(${1:element})\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_buildSet"
+    },
+    {
+      "label": "emptyList",
+      "kind": 1,
+      "detail": "fun <T> emptyList(): List<T>",
+      "documentation": {"value": "```kotlin\nfun <T> emptyList(): List<T>\n```\nReturns an empty read-only list."},
+      "insertText": "emptyList<${1:Type}>()",
+      "insertTextRules": 4,
+      "sortText": "02_function_emptyList"
+    },
+    {
+      "label": "emptyMap",
+      "kind": 1,
+      "detail": "fun <K, V> emptyMap(): Map<K, V>",
+      "documentation": {"value": "```kotlin\nfun <K, V> emptyMap(): Map<K, V>\n```\nReturns an empty read-only map."},
+      "insertText": "emptyMap<${1:K}, ${2:V}>()",
+      "insertTextRules": 4,
+      "sortText": "02_function_emptyMap"
+    },
+    {
+      "label": "emptySet",
+      "kind": 1,
+      "detail": "fun <T> emptySet(): Set<T>",
+      "documentation": {"value": "```kotlin\nfun <T> emptySet(): Set<T>\n```\nReturns an empty read-only set."},
+      "insertText": "emptySet<${1:Type}>()",
+      "insertTextRules": 4,
+      "sortText": "02_function_emptySet"
+    },
+    {
+      "label": "Int",
+      "kind": 5,
+      "detail": "class Int : Number, Comparable<Int>",
+      "documentation": {"value": "32-bit signed integer type."},
+      "insertText": "Int",
+      "insertTextRules": 0,
+      "sortText": "03_type_Int"
+    },
+    {
+      "label": "Long",
+      "kind": 5,
+      "detail": "class Long : Number, Comparable<Long>",
+      "documentation": {"value": "64-bit signed integer type."},
+      "insertText": "Long",
+      "insertTextRules": 0,
+      "sortText": "03_type_Long"
+    },
+    {
+      "label": "Short",
+      "kind": 5,
+      "detail": "class Short : Number, Comparable<Short>",
+      "documentation": {"value": "16-bit signed integer type."},
+      "insertText": "Short",
+      "insertTextRules": 0,
+      "sortText": "03_type_Short"
+    },
+    {
+      "label": "Byte",
+      "kind": 5,
+      "detail": "class Byte : Number, Comparable<Byte>",
+      "documentation": {"value": "8-bit signed integer type."},
+      "insertText": "Byte",
+      "insertTextRules": 0,
+      "sortText": "03_type_Byte"
+    },
+    {
+      "label": "Float",
+      "kind": 5,
+      "detail": "class Float : Number, Comparable<Float>",
+      "documentation": {"value": "32-bit IEEE 754 floating point number."},
+      "insertText": "Float",
+      "insertTextRules": 0,
+      "sortText": "03_type_Float"
+    },
+    {
+      "label": "Double",
+      "kind": 5,
+      "detail": "class Double : Number, Comparable<Double>",
+      "documentation": {"value": "64-bit IEEE 754 floating point number."},
+      "insertText": "Double",
+      "insertTextRules": 0,
+      "sortText": "03_type_Double"
+    },
+    {
+      "label": "Boolean",
+      "kind": 5,
+      "detail": "class Boolean : Comparable<Boolean>",
+      "documentation": {"value": "Boolean type with two possible values: true and false."},
+      "insertText": "Boolean",
+      "insertTextRules": 0,
+      "sortText": "03_type_Boolean"
+    },
+    {
+      "label": "Char",
+      "kind": 5,
+      "detail": "class Char : Comparable<Char>",
+      "documentation": {"value": "16-bit Unicode character type."},
+      "insertText": "Char",
+      "insertTextRules": 0,
+      "sortText": "03_type_Char"
+    },
+    {
+      "label": "String",
+      "kind": 5,
+      "detail": "class String : Comparable<String>, CharSequence",
+      "documentation": {"value": "Immutable sequence of characters."},
+      "insertText": "String",
+      "insertTextRules": 0,
+      "sortText": "03_type_String"
+    },
+    {
+      "label": "Unit",
+      "kind": 5,
+      "detail": "object Unit",
+      "documentation": {"value": "The type with only one value: Unit. Corresponds to void in Java."},
+      "insertText": "Unit",
+      "insertTextRules": 0,
+      "sortText": "03_type_Unit"
+    },
+    {
+      "label": "Nothing",
+      "kind": 5,
+      "detail": "class Nothing",
+      "documentation": {"value": "Type that has no instances. Used for functions that never return (e.g., throw)."},
+      "insertText": "Nothing",
+      "insertTextRules": 0,
+      "sortText": "03_type_Nothing"
+    },
+    {
+      "label": "Any",
+      "kind": 5,
+      "detail": "open class Any",
+      "documentation": {"value": "Root of the Kotlin class hierarchy. Every class has Any as a supertype."},
+      "insertText": "Any",
+      "insertTextRules": 0,
+      "sortText": "03_type_Any"
+    },
+    {
+      "label": "Array",
+      "kind": 5,
+      "detail": "class Array<T>",
+      "documentation": {"value": "Represents an array. Use arrayOf() to create."},
+      "insertText": "Array<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_Array"
+    },
+    {
+      "label": "List",
+      "kind": 7,
+      "detail": "interface List<out E> : Collection<E>",
+      "documentation": {"value": "Read-only ordered collection of elements."},
+      "insertText": "List<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_List"
+    },
+    {
+      "label": "MutableList",
+      "kind": 7,
+      "detail": "interface MutableList<E> : List<E>, MutableCollection<E>",
+      "documentation": {"value": "Mutable ordered collection supporting add/remove."},
+      "insertText": "MutableList<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_MutableList"
+    },
+    {
+      "label": "Map",
+      "kind": 7,
+      "detail": "interface Map<K, out V>",
+      "documentation": {"value": "Read-only collection of key-value pairs."},
+      "insertText": "Map<${1:Key}, ${2:Value}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_Map"
+    },
+    {
+      "label": "MutableMap",
+      "kind": 7,
+      "detail": "interface MutableMap<K, V> : Map<K, V>",
+      "documentation": {"value": "Mutable collection of key-value pairs."},
+      "insertText": "MutableMap<${1:Key}, ${2:Value}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_MutableMap"
+    },
+    {
+      "label": "Set",
+      "kind": 7,
+      "detail": "interface Set<out E> : Collection<E>",
+      "documentation": {"value": "Read-only collection of unique elements."},
+      "insertText": "Set<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_Set"
+    },
+    {
+      "label": "MutableSet",
+      "kind": 7,
+      "detail": "interface MutableSet<E> : Set<E>, MutableCollection<E>",
+      "documentation": {"value": "Mutable collection of unique elements."},
+      "insertText": "MutableSet<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_MutableSet"
+    },
+    {
+      "label": "Pair",
+      "kind": 5,
+      "detail": "data class Pair<out A, out B>",
+      "documentation": {"value": "Represents a generic pair of two values. Create with `to` infix function."},
+      "insertText": "Pair(${1:first}, ${2:second})",
+      "insertTextRules": 4,
+      "sortText": "03_type_Pair"
+    },
+    {
+      "label": "Triple",
+      "kind": 5,
+      "detail": "data class Triple<out A, out B, out C>",
+      "documentation": {"value": "Represents a triple of three values."},
+      "insertText": "Triple(${1:first}, ${2:second}, ${3:third})",
+      "insertTextRules": 4,
+      "sortText": "03_type_Triple"
+    },
+    {
+      "label": "Sequence",
+      "kind": 7,
+      "detail": "interface Sequence<out T>",
+      "documentation": {"value": "A sequence of values that are lazily evaluated."},
+      "insertText": "Sequence<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_Sequence"
+    },
+    {
+      "label": "Iterable",
+      "kind": 7,
+      "detail": "interface Iterable<out T>",
+      "documentation": {"value": "Classes that inherit from this interface can be iterated over."},
+      "insertText": "Iterable<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_Iterable"
+    },
+    {
+      "label": "Collection",
+      "kind": 7,
+      "detail": "interface Collection<out E> : Iterable<E>",
+      "documentation": {"value": "A generic collection of elements. Provides read-only access."},
+      "insertText": "Collection<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_Collection"
+    },
+    {
+      "label": "fun main",
+      "kind": 28,
+      "detail": "Main function entry point",
+      "documentation": {"value": "```kotlin\nfun main(args: Array<String>) {\n    println(\"Hello, World!\")\n}\n```\nProgram entry point."},
+      "insertText": "fun main(args: Array<String>) {\n\t${1:println(\"Hello, World!\")}\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_main"
+    },
+    {
+      "label": "data class",
+      "kind": 28,
+      "detail": "Data class declaration",
+      "documentation": {"value": "```kotlin\ndata class Name(\n    val property: Type\n)\n```\nA class primarily for holding data with auto-generated equals, hashCode, toString, copy."},
+      "insertText": "data class ${1:Name}(\n\tval ${2:property}: ${3:Type}\n)",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_data_class"
+    },
+    {
+      "label": "sealed class",
+      "kind": 28,
+      "detail": "Sealed class declaration",
+      "documentation": {"value": "```kotlin\nsealed class Result {\n    data class Success(val data: String) : Result()\n    data class Error(val message: String) : Result()\n}\n```\nRestricted class hierarchy."},
+      "insertText": "sealed class ${1:Name} {\n\tdata class ${2:Success}(val ${3:data}: ${4:String}) : ${1:Name}()\n\tdata class ${5:Error}(val ${6:message}: ${7:String}) : ${1:Name}()\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_sealed_class"
+    },
+    {
+      "label": "enum class",
+      "kind": 28,
+      "detail": "Enum class declaration",
+      "documentation": {"value": "```kotlin\nenum class Direction {\n    NORTH, SOUTH, EAST, WEST\n}\n```\nDeclares an enum class with a fixed set of constants."},
+      "insertText": "enum class ${1:Name} {\n\t${2:VALUE1},\n\t${3:VALUE2}\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_enum_class"
+    },
+    {
+      "label": "object declaration",
+      "kind": 28,
+      "detail": "Singleton object declaration",
+      "documentation": {"value": "```kotlin\nobject Singleton {\n    fun doSomething() { }\n}\n```\nDeclares a singleton."},
+      "insertText": "object ${1:Name} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_object"
+    },
+    {
+      "label": "companion object",
+      "kind": 28,
+      "detail": "Companion object declaration",
+      "documentation": {"value": "```kotlin\ncompanion object {\n    const val TAG = \"MyClass\"\n    fun create(): MyClass = MyClass()\n}\n```\nStatic-like members for a class."},
+      "insertText": "companion object {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_companion"
+    },
+    {
+      "label": "extension function",
+      "kind": 28,
+      "detail": "Extension function declaration",
+      "documentation": {"value": "```kotlin\nfun String.addExclamation(): String {\n    return this + \"!\"\n}\n```\nAdds a function to an existing class without modifying it."},
+      "insertText": "fun ${1:Type}.${2:name}(${3:params}): ${4:ReturnType} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_extension_fun"
+    },
+    {
+      "label": "coroutine launch",
+      "kind": 28,
+      "detail": "Launch a coroutine",
+      "documentation": {"value": "```kotlin\nimport kotlinx.coroutines.*\n\nfun main() = runBlocking {\n    launch {\n        delay(1000L)\n        println(\"World!\")\n    }\n    println(\"Hello\")\n}\n```\nLaunches a new coroutine."},
+      "insertText": "launch {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_coroutine_launch"
+    },
+    {
+      "label": "flow",
+      "kind": 28,
+      "detail": "Kotlin Flow builder",
+      "documentation": {"value": "```kotlin\nfun simpleFlow(): Flow<Int> = flow {\n    for (i in 1..3) {\n        delay(100)\n        emit(i)\n    }\n}\n```\nCreates a cold asynchronous stream."},
+      "insertText": "flow {\n\temit(${1:value})\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_flow"
+    },
+    {
+      "label": "when expression",
+      "kind": 28,
+      "detail": "When expression with branches",
+      "documentation": {"value": "```kotlin\nwhen (x) {\n    1 -> print(\"one\")\n    2 -> print(\"two\")\n    else -> print(\"other\")\n}\n```\nPattern matching expression."},
+      "insertText": "when (${1:value}) {\n\t${2:condition} -> ${3:result}\n\telse -> ${4:default}\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_when"
+    },
+    {
+      "label": "try-catch",
+      "kind": 28,
+      "detail": "Try-catch block",
+      "documentation": {"value": "```kotlin\ntry {\n    // risky code\n} catch (e: Exception) {\n    e.printStackTrace()\n} finally {\n    // cleanup\n}\n```"},
+      "insertText": "try {\n\t${1:// code}\n} catch (e: ${2:Exception}) {\n\t${3:e.printStackTrace()}\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_try_catch"
+    },
+    {
+      "label": "for loop",
+      "kind": 28,
+      "detail": "For loop over collection or range",
+      "documentation": {"value": "```kotlin\nfor (item in collection) {\n    println(item)\n}\n```"},
+      "insertText": "for (${1:item} in ${2:collection}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_for_loop"
+    },
+    {
+      "label": "while loop",
+      "kind": 28,
+      "detail": "While loop",
+      "documentation": {"value": "```kotlin\nwhile (condition) {\n    // body\n}\n```"},
+      "insertText": "while (${1:condition}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_while_loop"
+    },
+    {
+      "label": "map/filter",
+      "kind": 28,
+      "detail": "Collection map and filter chain",
+      "documentation": {"value": "```kotlin\nval result = list\n    .filter { it > 0 }\n    .map { it * 2 }\n```\nFunctional collection processing."},
+      "insertText": "${1:collection}\n\t.filter { ${2:condition} }\n\t.map { ${3:transform} }",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_map_filter"
+    },
+    {
+      "label": "interface implementation",
+      "kind": 28,
+      "detail": "Class implementing an interface",
+      "documentation": {"value": "```kotlin\nclass MyClass : MyInterface {\n    override fun method() {\n        // implementation\n    }\n}\n```"},
+      "insertText": "class ${1:Name} : ${2:Interface} {\n\toverride fun ${3:method}(${4:params}): ${5:Unit} {\n\t\t$0\n\t}\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_interface_impl"
+    },
+    {
+      "label": "suspend function",
+      "kind": 28,
+      "detail": "Suspending function declaration",
+      "documentation": {"value": "```kotlin\nsuspend fun fetchData(): Result {\n    return withContext(Dispatchers.IO) {\n        // async work\n    }\n}\n```"},
+      "insertText": "suspend fun ${1:name}(${2:params}): ${3:ReturnType} {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_suspend_fun"
+    },
+    {
+      "label": "lazy property",
+      "kind": 28,
+      "detail": "Lazy initialized property",
+      "documentation": {"value": "```kotlin\nval myValue: String by lazy {\n    computeValue()\n}\n```\nProperty initialized on first access."},
+      "insertText": "val ${1:name}: ${2:Type} by lazy {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_lazy_property"
+    },
+    {
+      "label": "singleton pattern",
+      "kind": 28,
+      "detail": "Singleton with object declaration",
+      "documentation": {"value": "```kotlin\nobject DatabaseManager {\n    private val connection = createConnection()\n    fun query(sql: String) = connection.execute(sql)\n}\n```\nKotlin's built-in singleton pattern using object."},
+      "insertText": "object ${1:Name} {\n\tprivate val ${2:instance} = ${3:create()}\n\t\n\tfun ${4:method}(${5:params}): ${6:Unit} {\n\t\t$0\n\t}\n}",
+      "insertTextRules": 4,
+      "sortText": "04_snippet_singleton"
+    },
+    {
+      "label": "runBlocking",
+      "kind": 1,
+      "detail": "fun <T> runBlocking(block: suspend CoroutineScope.() -> T): T",
+      "documentation": {"value": "```kotlin\nfun <T> runBlocking(block: suspend CoroutineScope.() -> T): T\n```\nRuns a new coroutine and blocks the current thread until it completes."},
+      "insertText": "runBlocking {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_runBlocking"
+    },
+    {
+      "label": "withContext",
+      "kind": 1,
+      "detail": "suspend fun <T> withContext(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T",
+      "documentation": {"value": "```kotlin\nsuspend fun <T> withContext(context: CoroutineContext, block: suspend CoroutineScope.() -> T): T\n```\nCalls the given suspend block with a specified coroutine context."},
+      "insertText": "withContext(${1:Dispatchers.IO}) {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_withContext"
+    },
+    {
+      "label": "async",
+      "kind": 1,
+      "detail": "fun <T> CoroutineScope.async(block: suspend CoroutineScope.() -> T): Deferred<T>",
+      "documentation": {"value": "```kotlin\nfun <T> CoroutineScope.async(block: suspend CoroutineScope.() -> T): Deferred<T>\n```\nCreates a coroutine and returns its future result as Deferred."},
+      "insertText": "async {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_async"
+    },
+    {
+      "label": "launch",
+      "kind": 1,
+      "detail": "fun CoroutineScope.launch(block: suspend CoroutineScope.() -> Unit): Job",
+      "documentation": {"value": "```kotlin\nfun CoroutineScope.launch(block: suspend CoroutineScope.() -> Unit): Job\n```\nLaunches a new coroutine without blocking the current thread."},
+      "insertText": "launch {\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_launch"
+    },
+    {
+      "label": "delay",
+      "kind": 1,
+      "detail": "suspend fun delay(timeMillis: Long)",
+      "documentation": {"value": "```kotlin\nsuspend fun delay(timeMillis: Long)\n```\nDelays coroutine for a given time without blocking the thread."},
+      "insertText": "delay(${1:1000L})",
+      "insertTextRules": 4,
+      "sortText": "02_function_delay"
+    },
+    {
+      "label": "forEach",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.forEach(action: (T) -> Unit)",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.forEach(action: (T) -> Unit)\n```\nPerforms the given action on each element."},
+      "insertText": "forEach { ${1:item} ->\n\t$0\n}",
+      "insertTextRules": 4,
+      "sortText": "02_function_forEach"
+    },
+    {
+      "label": "map",
+      "kind": 1,
+      "detail": "fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>",
+      "documentation": {"value": "```kotlin\nfun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>\n```\nReturns a list containing the results of applying the given transform to each element."},
+      "insertText": "map { ${1:it} -> ${2:transform} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_map"
+    },
+    {
+      "label": "filter",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>\n```\nReturns a list containing only elements matching the given predicate."},
+      "insertText": "filter { ${1:condition} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_filter"
+    },
+    {
+      "label": "flatMap",
+      "kind": 1,
+      "detail": "fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>",
+      "documentation": {"value": "```kotlin\nfun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>\n```\nReturns a single list of all elements yielded from the transform applied to each element."},
+      "insertText": "flatMap { ${1:it} -> ${2:transform} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_flatMap"
+    },
+    {
+      "label": "reduce",
+      "kind": 1,
+      "detail": "fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S",
+      "documentation": {"value": "```kotlin\nfun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S\n```\nAccumulates value starting with the first element and applying operation from left to right."},
+      "insertText": "reduce { ${1:acc}, ${2:item} -> ${3:acc + item} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_reduce"
+    },
+    {
+      "label": "fold",
+      "kind": 1,
+      "detail": "fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R",
+      "documentation": {"value": "```kotlin\nfun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R\n```\nAccumulates value starting with initial and applying operation from left to right."},
+      "insertText": "fold(${1:initial}) { ${2:acc}, ${3:item} -> ${4:acc + item} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_fold"
+    },
+    {
+      "label": "groupBy",
+      "kind": 1,
+      "detail": "fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>",
+      "documentation": {"value": "```kotlin\nfun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>\n```\nGroups elements by the key returned by the given function."},
+      "insertText": "groupBy { ${1:keySelector} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_groupBy"
+    },
+    {
+      "label": "sortedBy",
+      "kind": 1,
+      "detail": "fun <T, R : Comparable<R>> Iterable<T>.sortedBy(selector: (T) -> R?): List<T>",
+      "documentation": {"value": "```kotlin\nfun <T, R : Comparable<R>> Iterable<T>.sortedBy(selector: (T) -> R?): List<T>\n```\nReturns a list sorted by the value of the given selector."},
+      "insertText": "sortedBy { ${1:selector} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_sortedBy"
+    },
+    {
+      "label": "associate",
+      "kind": 1,
+      "detail": "fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>",
+      "documentation": {"value": "```kotlin\nfun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>\n```\nReturns a Map containing key-value pairs from the given transform."},
+      "insertText": "associate { ${1:it} to ${2:value} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_associate"
+    },
+    {
+      "label": "first",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.first(): T",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.first(): T\n```\nReturns the first element. Throws if collection is empty."},
+      "insertText": "first()",
+      "insertTextRules": 0,
+      "sortText": "02_function_first"
+    },
+    {
+      "label": "firstOrNull",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.firstOrNull(): T?",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.firstOrNull(): T?\n```\nReturns the first element, or null if collection is empty."},
+      "insertText": "firstOrNull()",
+      "insertTextRules": 0,
+      "sortText": "02_function_firstOrNull"
+    },
+    {
+      "label": "any",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean\n```\nReturns true if at least one element matches the given predicate."},
+      "insertText": "any { ${1:predicate} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_any"
+    },
+    {
+      "label": "all",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean\n```\nReturns true if all elements match the given predicate."},
+      "insertText": "all { ${1:predicate} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_all"
+    },
+    {
+      "label": "none",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean\n```\nReturns true if no elements match the given predicate."},
+      "insertText": "none { ${1:predicate} }",
+      "insertTextRules": 4,
+      "sortText": "02_function_none"
+    },
+    {
+      "label": "count",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.count(): Int",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.count(): Int\n```\nReturns the number of elements in the collection."},
+      "insertText": "count()",
+      "insertTextRules": 0,
+      "sortText": "02_function_count"
+    },
+    {
+      "label": "sum",
+      "kind": 1,
+      "detail": "fun Iterable<Int>.sum(): Int",
+      "documentation": {"value": "```kotlin\nfun Iterable<Int>.sum(): Int\n```\nReturns the sum of all elements."},
+      "insertText": "sum()",
+      "insertTextRules": 0,
+      "sortText": "02_function_sum"
+    },
+    {
+      "label": "joinToString",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.joinToString(separator: CharSequence = \", \"): String",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.joinToString(separator: CharSequence = \", \"): String\n```\nCreates a string from all the elements with the given separator."},
+      "insertText": "joinToString(\"${1:, }\")",
+      "insertTextRules": 4,
+      "sortText": "02_function_joinToString"
+    },
+    {
+      "label": "toList",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.toList(): List<T>",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.toList(): List<T>\n```\nReturns a List containing all elements."},
+      "insertText": "toList()",
+      "insertTextRules": 0,
+      "sortText": "02_function_toList"
+    },
+    {
+      "label": "toMutableList",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.toMutableList(): MutableList<T>",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.toMutableList(): MutableList<T>\n```\nReturns a MutableList containing all elements."},
+      "insertText": "toMutableList()",
+      "insertTextRules": 0,
+      "sortText": "02_function_toMutableList"
+    },
+    {
+      "label": "toSet",
+      "kind": 1,
+      "detail": "fun <T> Iterable<T>.toSet(): Set<T>",
+      "documentation": {"value": "```kotlin\nfun <T> Iterable<T>.toSet(): Set<T>\n```\nReturns a Set containing all distinct elements."},
+      "insertText": "toSet()",
+      "insertTextRules": 0,
+      "sortText": "02_function_toSet"
+    },
+    {
+      "label": "toMap",
+      "kind": 1,
+      "detail": "fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>",
+      "documentation": {"value": "```kotlin\nfun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>\n```\nReturns a Map from an iterable of pairs."},
+      "insertText": "toMap()",
+      "insertTextRules": 0,
+      "sortText": "02_function_toMap"
+    },
+    {
+      "label": "toString",
+      "kind": 1,
+      "detail": "fun Any?.toString(): String",
+      "documentation": {"value": "```kotlin\nfun Any?.toString(): String\n```\nReturns a string representation of the object."},
+      "insertText": "toString()",
+      "insertTextRules": 0,
+      "sortText": "02_function_toString"
+    },
+    {
+      "label": "toInt",
+      "kind": 1,
+      "detail": "fun String.toInt(): Int",
+      "documentation": {"value": "```kotlin\nfun String.toInt(): Int\n```\nParses the string as a signed Int. Throws NumberFormatException if not valid."},
+      "insertText": "toInt()",
+      "insertTextRules": 0,
+      "sortText": "02_function_toInt"
+    },
+    {
+      "label": "toDouble",
+      "kind": 1,
+      "detail": "fun String.toDouble(): Double",
+      "documentation": {"value": "```kotlin\nfun String.toDouble(): Double\n```\nParses the string as a Double. Throws NumberFormatException if not valid."},
+      "insertText": "toDouble()",
+      "insertTextRules": 0,
+      "sortText": "02_function_toDouble"
+    },
+    {
+      "label": "toIntOrNull",
+      "kind": 1,
+      "detail": "fun String.toIntOrNull(): Int?",
+      "documentation": {"value": "```kotlin\nfun String.toIntOrNull(): Int?\n```\nParses the string as a signed Int. Returns null if not valid."},
+      "insertText": "toIntOrNull()",
+      "insertTextRules": 0,
+      "sortText": "02_function_toIntOrNull"
+    },
+    {
+      "label": "Regex",
+      "kind": 5,
+      "detail": "class Regex",
+      "documentation": {"value": "Represents a compiled regular expression. Use Regex(pattern) or \"pattern\".toRegex()."},
+      "insertText": "Regex(\"${1:pattern}\")",
+      "insertTextRules": 4,
+      "sortText": "03_type_Regex"
+    },
+    {
+      "label": "Result",
+      "kind": 5,
+      "detail": "value class Result<out T>",
+      "documentation": {"value": "Encapsulates a successful or failed result with value or exception."},
+      "insertText": "Result",
+      "insertTextRules": 0,
+      "sortText": "03_type_Result"
+    },
+    {
+      "label": "Comparable",
+      "kind": 7,
+      "detail": "interface Comparable<in T>",
+      "documentation": {"value": "Interface for types with a natural ordering."},
+      "insertText": "Comparable<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_Comparable"
+    },
+    {
+      "label": "Lazy",
+      "kind": 7,
+      "detail": "interface Lazy<out T>",
+      "documentation": {"value": "Represents a value with lazy initialization."},
+      "insertText": "Lazy<${1:Type}>",
+      "insertTextRules": 4,
+      "sortText": "03_type_Lazy"
+    },
+    {
+      "label": "Number",
+      "kind": 5,
+      "detail": "abstract class Number",
+      "documentation": {"value": "Superclass for all numeric types: Int, Long, Short, Byte, Float, Double."},
+      "insertText": "Number",
+      "insertTextRules": 0,
+      "sortText": "03_type_Number"
+    },
+    {
+      "label": "Throwable",
+      "kind": 5,
+      "detail": "open class Throwable",
+      "documentation": {"value": "Base class for all errors and exceptions."},
+      "insertText": "Throwable",
+      "insertTextRules": 0,
+      "sortText": "03_type_Throwable"
+    },
+    {
+      "label": "Exception",
+      "kind": 5,
+      "detail": "open class Exception : Throwable",
+      "documentation": {"value": "Base class for all exceptions."},
+      "insertText": "Exception(\"${1:message}\")",
+      "insertTextRules": 4,
+      "sortText": "03_type_Exception"
+    },
+    {
+      "label": "IllegalArgumentException",
+      "kind": 5,
+      "detail": "class IllegalArgumentException : RuntimeException",
+      "documentation": {"value": "Thrown when an illegal argument is passed to a function."},
+      "insertText": "IllegalArgumentException(\"${1:message}\")",
+      "insertTextRules": 4,
+      "sortText": "03_type_IllegalArgumentException"
+    },
+    {
+      "label": "IllegalStateException",
+      "kind": 5,
+      "detail": "class IllegalStateException : RuntimeException",
+      "documentation": {"value": "Thrown when a method is called at an illegal or inappropriate time."},
+      "insertText": "IllegalStateException(\"${1:message}\")",
+      "insertTextRules": 4,
+      "sortText": "03_type_IllegalStateException"
+    },
+    {
+      "label": "StringBuilder",
+      "kind": 5,
+      "detail": "class StringBuilder : Appendable, CharSequence",
+      "documentation": {"value": "Mutable sequence of characters for efficient string building."},
+      "insertText": "StringBuilder()",
+      "insertTextRules": 0,
+      "sortText": "03_type_StringBuilder"
+    },
+    {
+      "label": "IntRange",
+      "kind": 5,
+      "detail": "class IntRange : IntProgression, ClosedRange<Int>",
+      "documentation": {"value": "A range of Int values. Created with `..` operator: `1..10`."},
+      "insertText": "IntRange(${1:start}, ${2:endInclusive})",
+      "insertTextRules": 4,
+      "sortText": "03_type_IntRange"
+    }
+  ]
+}