@enjoys/context-engine 1.1.2 → 1.2.0

package/data/signatureHelp/elixir.json

@@ -0,0 +1,123 @@
+{
+  "language": "elixir",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "IO.puts(item): :ok",
+      "documentation": { "value": "Writes `item` to standard output followed by a newline.\n```elixir\nIO.puts(\"Hello World\")\nIO.puts(42)\nIO.puts(inspect(%{a: 1}))\n```" },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The item to write. Converted to a string via `to_string/1`." } }
+      ]
+    },
+    {
+      "label": "Enum.map(enumerable, fun): list",
+      "documentation": { "value": "Returns a list where each element is the result of invoking `fun` on each element of `enumerable`.\n```elixir\nEnum.map([1, 2, 3], fn x -> x * 2 end)  # [2, 4, 6]\nEnum.map([1, 2, 3], &(&1 * 2))          # [2, 4, 6]\n```" },
+      "parameters": [
+        { "label": "enumerable", "documentation": { "value": "The enumerable to map over (list, map, range, etc.)." } },
+        { "label": "fun", "documentation": { "value": "A function `(element -> new_element)` applied to each element." } }
+      ]
+    },
+    {
+      "label": "Enum.filter(enumerable, fun): list",
+      "documentation": { "value": "Filters the enumerable, keeping only elements for which `fun` returns a truthy value.\n```elixir\nEnum.filter([1, 2, 3, 4], fn x -> rem(x, 2) == 0 end)  # [2, 4]\nEnum.filter([1, nil, 3, false], & &1)                    # [1, 3]\n```" },
+      "parameters": [
+        { "label": "enumerable", "documentation": { "value": "The enumerable to filter." } },
+        { "label": "fun", "documentation": { "value": "A predicate function `(element -> boolean)`." } }
+      ]
+    },
+    {
+      "label": "Enum.reduce(enumerable, acc, fun): value",
+      "documentation": { "value": "Reduces the enumerable to a single value using `fun`.\n```elixir\nEnum.reduce([1, 2, 3], 0, fn x, acc -> acc + x end)  # 6\nEnum.reduce([\"a\", \"b\", \"c\"], \"\", &(&2 <> &1))        # \"abc\"\n```" },
+      "parameters": [
+        { "label": "enumerable", "documentation": { "value": "The enumerable to reduce." } },
+        { "label": "acc", "documentation": { "value": "The initial accumulator value." } },
+        { "label": "fun", "documentation": { "value": "A function `(element, acc -> new_acc)` applied at each step." } }
+      ]
+    },
+    {
+      "label": "String.split(string, pattern, opts \\\\ []): list",
+      "documentation": { "value": "Splits a string on occurrences of `pattern`.\n```elixir\nString.split(\"hello world\", \" \")       # [\"hello\", \"world\"]\nString.split(\"a,b,,c\", \",\", trim: true) # [\"a\", \"b\", \"c\"]\nString.split(\"abc\", \"\")                 # [\"a\", \"b\", \"c\"]\n```" },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The string to split." } },
+        { "label": "pattern", "documentation": { "value": "A string, regex, or list of strings to split on." } },
+        { "label": "opts", "documentation": { "value": "Options: `trim: true` to remove empty strings, `parts: n` to limit splits." } }
+      ]
+    },
+    {
+      "label": "String.replace(subject, pattern, replacement, opts \\\\ []): String.t()",
+      "documentation": { "value": "Replaces occurrences of `pattern` in `subject` with `replacement`.\n```elixir\nString.replace(\"hello world\", \"world\", \"elixir\")  # \"hello elixir\"\nString.replace(\"aaa\", \"a\", \"b\", global: false)     # \"baa\"\n```" },
+      "parameters": [
+        { "label": "subject", "documentation": { "value": "The original string." } },
+        { "label": "pattern", "documentation": { "value": "A string or regex to match." } },
+        { "label": "replacement", "documentation": { "value": "The replacement string or function." } },
+        { "label": "opts", "documentation": { "value": "Options: `global: false` to replace only the first occurrence." } }
+      ]
+    },
+    {
+      "label": "Map.get(map, key, default \\\\ nil): value",
+      "documentation": { "value": "Gets the value for a specific key in the map.\n```elixir\nMap.get(%{a: 1, b: 2}, :a)        # 1\nMap.get(%{a: 1}, :c, :default)    # :default\nMap.get(%{a: 1}, :c)              # nil\n```" },
+      "parameters": [
+        { "label": "map", "documentation": { "value": "The map to look up." } },
+        { "label": "key", "documentation": { "value": "The key to fetch." } },
+        { "label": "default", "documentation": { "value": "Value returned if key is not found (default: `nil`)." } }
+      ]
+    },
+    {
+      "label": "Map.put(map, key, value): map",
+      "documentation": { "value": "Puts the given `value` under `key` in `map`.\n```elixir\nMap.put(%{a: 1}, :b, 2)   # %{a: 1, b: 2}\nMap.put(%{a: 1}, :a, 99)  # %{a: 99}\n```" },
+      "parameters": [
+        { "label": "map", "documentation": { "value": "The map to update." } },
+        { "label": "key", "documentation": { "value": "The key to set." } },
+        { "label": "value", "documentation": { "value": "The value to associate with the key." } }
+      ]
+    },
+    {
+      "label": "List.first(list, default \\\\ nil): value",
+      "documentation": { "value": "Returns the first element of `list`, or `default` if empty.\n```elixir\nList.first([1, 2, 3])     # 1\nList.first([], :none)     # :none\n```" },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The list." } },
+        { "label": "default", "documentation": { "value": "Value returned if the list is empty (default: `nil`)." } }
+      ]
+    },
+    {
+      "label": "Kernel.is_nil(term): boolean",
+      "documentation": { "value": "Returns `true` if `term` is `nil`, `false` otherwise. Allowed in guard clauses.\n```elixir\nis_nil(nil)    # true\nis_nil(42)     # false\n```" },
+      "parameters": [
+        { "label": "term", "documentation": { "value": "The term to check." } }
+      ]
+    },
+    {
+      "label": "GenServer.call(server, request, timeout \\\\ 5000): response",
+      "documentation": { "value": "Makes a synchronous call to a GenServer and waits for a reply.\n```elixir\nGenServer.call(pid, :get_state)\nGenServer.call(MyServer, {:update, value}, 10_000)\n```" },
+      "parameters": [
+        { "label": "server", "documentation": { "value": "The GenServer pid, name, or `{name, node}` tuple." } },
+        { "label": "request", "documentation": { "value": "The request term sent to `handle_call/3`." } },
+        { "label": "timeout", "documentation": { "value": "Timeout in milliseconds (default: 5000). Use `:infinity` for no timeout." } }
+      ]
+    },
+    {
+      "label": "GenServer.cast(server, request): :ok",
+      "documentation": { "value": "Sends an asynchronous request to a GenServer (fire-and-forget).\n```elixir\nGenServer.cast(pid, {:increment, 1})\nGenServer.cast(MyServer, :reset)\n```" },
+      "parameters": [
+        { "label": "server", "documentation": { "value": "The GenServer pid, name, or `{name, node}` tuple." } },
+        { "label": "request", "documentation": { "value": "The request term sent to `handle_cast/2`." } }
+      ]
+    },
+    {
+      "label": "Task.async(fun): Task.t()",
+      "documentation": { "value": "Starts a task that must be awaited on. The result is collected with `Task.await/2`.\n```elixir\ntask = Task.async(fn -> expensive_computation() end)\nresult = Task.await(task)\n```" },
+      "parameters": [
+        { "label": "fun", "documentation": { "value": "A zero-arity function to execute asynchronously." } }
+      ]
+    },
+    {
+      "label": "Agent.start_link(fun, opts \\\\ []): {:ok, pid}",
+      "documentation": { "value": "Starts an agent linked to the current process with the given initial state.\n```elixir\n{:ok, agent} = Agent.start_link(fn -> %{} end)\n{:ok, agent} = Agent.start_link(fn -> 0 end, name: :counter)\n```" },
+      "parameters": [
+        { "label": "fun", "documentation": { "value": "A zero-arity function returning the initial state." } },
+        { "label": "opts", "documentation": { "value": "Options: `name:` to register the agent, `timeout:`, etc." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/flow9.json

@@ -0,0 +1,84 @@
+{
+  "language": "flow9",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "println(s: string): void",
+      "documentation": { "value": "Prints a string followed by a newline to standard output." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to print." } }
+      ]
+    },
+    {
+      "label": "strlen(s: string): int",
+      "documentation": { "value": "Returns the length of a string in characters." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to measure." } }
+      ]
+    },
+    {
+      "label": "strReplace(s: string, old: string, new: string): string",
+      "documentation": { "value": "Replaces all occurrences of a substring within a string." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The original string." } },
+        { "label": "old", "documentation": { "value": "The substring to search for." } },
+        { "label": "new", "documentation": { "value": "The replacement substring." } }
+      ]
+    },
+    {
+      "label": "i2s(i: int): string",
+      "documentation": { "value": "Converts an integer to its string representation." },
+      "parameters": [
+        { "label": "i", "documentation": { "value": "The integer to convert." } }
+      ]
+    },
+    {
+      "label": "s2i(s: string): int",
+      "documentation": { "value": "Parses a string as an integer. Returns 0 if parsing fails." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to parse." } }
+      ]
+    },
+    {
+      "label": "map(a: [?], fn: (?) -> ??): [??]",
+      "documentation": { "value": "Applies a function to each element of an array and returns a new array of results." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The input array." } },
+        { "label": "fn", "documentation": { "value": "The function to apply to each element." } }
+      ]
+    },
+    {
+      "label": "filter(a: [?], fn: (?) -> bool): [?]",
+      "documentation": { "value": "Returns a new array containing only elements for which the predicate returns true." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The input array." } },
+        { "label": "fn", "documentation": { "value": "The predicate function." } }
+      ]
+    },
+    {
+      "label": "fold(a: [?], init: ??, fn: (??, ?) -> ??): ??",
+      "documentation": { "value": "Reduces an array to a single value by applying a function with an accumulator." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The input array." } },
+        { "label": "init", "documentation": { "value": "The initial accumulator value." } },
+        { "label": "fn", "documentation": { "value": "The reducer function taking accumulator and element." } }
+      ]
+    },
+    {
+      "label": "isSameObj(a: ?, b: ?): bool",
+      "documentation": { "value": "Checks whether two values reference the same object in memory." },
+      "parameters": [
+        { "label": "a", "documentation": { "value": "The first value." } },
+        { "label": "b", "documentation": { "value": "The second value." } }
+      ]
+    },
+    {
+      "label": "ref(value: ?): ref<?>",
+      "documentation": { "value": "Creates a mutable reference cell containing the given value." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The initial value for the reference." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/freemarker2.json

@@ -0,0 +1,64 @@
+{
+  "language": "freemarker2",
+  "triggerCharacters": ["(", ",", "?"],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "?string: string",
+      "documentation": { "value": "Converts a value to its string representation. For numbers, uses the default number format. For booleans, converts to \"true\" or \"false\"." },
+      "parameters": []
+    },
+    {
+      "label": "?number: number",
+      "documentation": { "value": "Converts a string to a number. The string must be in a valid number format." },
+      "parameters": []
+    },
+    {
+      "label": "?date: date",
+      "documentation": { "value": "Converts a string to a date value using the configured date format." },
+      "parameters": []
+    },
+    {
+      "label": "?size: number",
+      "documentation": { "value": "Returns the number of elements in a sequence or the number of characters in a string." },
+      "parameters": []
+    },
+    {
+      "label": "?has_content: boolean",
+      "documentation": { "value": "Returns true if the variable exists and is not empty. For strings, checks that it's not blank; for sequences, checks length > 0." },
+      "parameters": []
+    },
+    {
+      "label": "?replace(target: string, replacement: string): string",
+      "documentation": { "value": "Replaces all occurrences of a substring within the string." },
+      "parameters": [
+        { "label": "target", "documentation": { "value": "The substring to search for." } },
+        { "label": "replacement", "documentation": { "value": "The string to replace matches with." } }
+      ]
+    },
+    {
+      "label": "?split(separator: string): sequence",
+      "documentation": { "value": "Splits a string into a sequence of substrings around the given separator." },
+      "parameters": [
+        { "label": "separator", "documentation": { "value": "The delimiter string to split on." } }
+      ]
+    },
+    {
+      "label": "?join(separator: string): string",
+      "documentation": { "value": "Joins the elements of a sequence into a single string, separated by the given delimiter." },
+      "parameters": [
+        { "label": "separator", "documentation": { "value": "The delimiter to place between elements." } }
+      ]
+    },
+    {
+      "label": "?upper_case: string",
+      "documentation": { "value": "Converts all characters in the string to upper case." },
+      "parameters": []
+    },
+    {
+      "label": "?lower_case: string",
+      "documentation": { "value": "Converts all characters in the string to lower case." },
+      "parameters": []
+    }
+  ]
+}

package/data/signatureHelp/go.json

@@ -0,0 +1,118 @@
+{
+  "language": "go",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "fmt.Println(a ...any): (n int, err error)",
+      "documentation": { "value": "Formats using the default formats for its operands and writes to standard output. Spaces are always added between operands and a newline is appended." },
+      "parameters": [
+        { "label": "a ...any", "documentation": { "value": "Values to print, separated by spaces." } }
+      ]
+    },
+    {
+      "label": "fmt.Sprintf(format string, a ...any): string",
+      "documentation": { "value": "Formats according to a format specifier and returns the resulting string." },
+      "parameters": [
+        { "label": "format string", "documentation": { "value": "A format string with verbs like %s, %d, %v, etc." } },
+        { "label": "a ...any", "documentation": { "value": "Values to format into the string." } }
+      ]
+    },
+    {
+      "label": "fmt.Fprintf(w io.Writer, format string, a ...any): (n int, err error)",
+      "documentation": { "value": "Formats according to a format specifier and writes to w." },
+      "parameters": [
+        { "label": "w io.Writer", "documentation": { "value": "The writer to write the formatted output to." } },
+        { "label": "format string", "documentation": { "value": "A format string with verbs like %s, %d, %v, etc." } },
+        { "label": "a ...any", "documentation": { "value": "Values to format into the string." } }
+      ]
+    },
+    {
+      "label": "len(v Type): int",
+      "documentation": { "value": "Returns the length of v depending on its type: string (number of bytes), array/slice (number of elements), map (number of keys), channel (number of queued elements)." },
+      "parameters": [
+        { "label": "v Type", "documentation": { "value": "A string, array, slice, map, or channel." } }
+      ]
+    },
+    {
+      "label": "cap(v Type): int",
+      "documentation": { "value": "Returns the capacity of v depending on its type: array (number of elements), slice (maximum length the slice can reach), channel (channel buffer capacity)." },
+      "parameters": [
+        { "label": "v Type", "documentation": { "value": "An array, slice, or channel." } }
+      ]
+    },
+    {
+      "label": "make(t Type, size ...int): Type",
+      "documentation": { "value": "Allocates and initializes a slice, map, or channel. For slices, size specifies the length and optional capacity. For maps, size is an optional initial capacity hint. For channels, size specifies the buffer capacity." },
+      "parameters": [
+        { "label": "t Type", "documentation": { "value": "The type of slice, map, or channel to create." } },
+        { "label": "size ...int", "documentation": { "value": "Length (and optional capacity for slices), or buffer size for channels." } }
+      ]
+    },
+    {
+      "label": "append(slice []T, elems ...T): []T",
+      "documentation": { "value": "Appends elements to the end of a slice. If the slice has sufficient capacity, the destination is resliced; otherwise, a new underlying array is allocated." },
+      "parameters": [
+        { "label": "slice []T", "documentation": { "value": "The slice to append to." } },
+        { "label": "elems ...T", "documentation": { "value": "Elements to append." } }
+      ]
+    },
+    {
+      "label": "copy(dst []T, src []T): int",
+      "documentation": { "value": "Copies elements from a source slice into a destination slice. Returns the number of elements copied, which is the minimum of len(dst) and len(src)." },
+      "parameters": [
+        { "label": "dst []T", "documentation": { "value": "The destination slice." } },
+        { "label": "src []T", "documentation": { "value": "The source slice." } }
+      ]
+    },
+    {
+      "label": "delete(m map[K]V, key K)",
+      "documentation": { "value": "Deletes the element with the specified key from the map. If the map is nil or there is no such element, delete is a no-op." },
+      "parameters": [
+        { "label": "m map[K]V", "documentation": { "value": "The map to delete from." } },
+        { "label": "key K", "documentation": { "value": "The key to delete." } }
+      ]
+    },
+    {
+      "label": "close(ch chan<- Type)",
+      "documentation": { "value": "Closes a channel, indicating that no more values will be sent on it. Sending to a closed channel causes a panic." },
+      "parameters": [
+        { "label": "ch chan<- Type", "documentation": { "value": "The channel to close." } }
+      ]
+    },
+    {
+      "label": "panic(v any)",
+      "documentation": { "value": "Stops normal execution of the current goroutine. When a function calls panic, normal execution stops and any deferred functions begin running. The panic value is reported when the program terminates." },
+      "parameters": [
+        { "label": "v any", "documentation": { "value": "The value to pass to the panic." } }
+      ]
+    },
+    {
+      "label": "recover(): any",
+      "documentation": { "value": "Allows a program to manage behavior of a panicking goroutine. Must be called inside a deferred function. Returns the panic value if called during panicking, nil otherwise." },
+      "parameters": []
+    },
+    {
+      "label": "errors.New(text string): error",
+      "documentation": { "value": "Returns a new error that formats as the given text. Each call to New returns a distinct error value even if the text is identical." },
+      "parameters": [
+        { "label": "text string", "documentation": { "value": "The error message text." } }
+      ]
+    },
+    {
+      "label": "strings.Contains(s string, substr string): bool",
+      "documentation": { "value": "Reports whether substr is within s." },
+      "parameters": [
+        { "label": "s string", "documentation": { "value": "The string to search in." } },
+        { "label": "substr string", "documentation": { "value": "The substring to search for." } }
+      ]
+    },
+    {
+      "label": "strconv.Atoi(s string): (int, error)",
+      "documentation": { "value": "Converts a string to an int. Equivalent to ParseInt(s, 10, 0), converted to type int." },
+      "parameters": [
+        { "label": "s string", "documentation": { "value": "The string representation of an integer." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/graphql.json

@@ -0,0 +1,82 @@
+{
+  "language": "graphql",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "type TypeName { ...fields }",
+      "documentation": { "value": "Defines an object type with named fields. Each field has a type and optional arguments." },
+      "parameters": [
+        { "label": "TypeName", "documentation": { "value": "The name of the object type." } }
+      ]
+    },
+    {
+      "label": "query QueryName($var: Type): ReturnType",
+      "documentation": { "value": "Defines a named query operation with optional variables for parameterized data fetching." },
+      "parameters": [
+        { "label": "QueryName", "documentation": { "value": "Optional name for the query operation." } },
+        { "label": "$var: Type", "documentation": { "value": "Variable declarations with their GraphQL types." } }
+      ]
+    },
+    {
+      "label": "mutation MutationName($var: Type): ReturnType",
+      "documentation": { "value": "Defines a mutation operation for creating, updating, or deleting data." },
+      "parameters": [
+        { "label": "MutationName", "documentation": { "value": "Optional name for the mutation operation." } },
+        { "label": "$var: Type", "documentation": { "value": "Variable declarations with their GraphQL types." } }
+      ]
+    },
+    {
+      "label": "subscription SubscriptionName($var: Type): ReturnType",
+      "documentation": { "value": "Defines a subscription operation for real-time data updates via a persistent connection." },
+      "parameters": [
+        { "label": "SubscriptionName", "documentation": { "value": "Optional name for the subscription operation." } },
+        { "label": "$var: Type", "documentation": { "value": "Variable declarations with their GraphQL types." } }
+      ]
+    },
+    {
+      "label": "input InputTypeName { ...fields }",
+      "documentation": { "value": "Defines an input object type used for complex arguments in queries and mutations." },
+      "parameters": [
+        { "label": "InputTypeName", "documentation": { "value": "The name of the input type." } }
+      ]
+    },
+    {
+      "label": "enum EnumName { VALUE1, VALUE2, ... }",
+      "documentation": { "value": "Defines an enumeration type restricted to a particular set of allowed values." },
+      "parameters": [
+        { "label": "EnumName", "documentation": { "value": "The name of the enum type." } }
+      ]
+    },
+    {
+      "label": "interface InterfaceName { ...fields }",
+      "documentation": { "value": "Defines an abstract interface type that other types can implement, ensuring they include the specified fields." },
+      "parameters": [
+        { "label": "InterfaceName", "documentation": { "value": "The name of the interface." } }
+      ]
+    },
+    {
+      "label": "union UnionName = Type1 | Type2 | ...",
+      "documentation": { "value": "Defines a union type representing one of several possible object types." },
+      "parameters": [
+        { "label": "UnionName", "documentation": { "value": "The name of the union type." } }
+      ]
+    },
+    {
+      "label": "scalar ScalarName",
+      "documentation": { "value": "Defines a custom scalar type for values that aren't covered by the default scalars (Int, Float, String, Boolean, ID)." },
+      "parameters": [
+        { "label": "ScalarName", "documentation": { "value": "The name of the custom scalar type." } }
+      ]
+    },
+    {
+      "label": "directive @directiveName(arg: Type) on LOCATION",
+      "documentation": { "value": "Defines a custom directive that annotates parts of a GraphQL schema or document." },
+      "parameters": [
+        { "label": "@directiveName", "documentation": { "value": "The name of the directive (prefixed with @)." } },
+        { "label": "arg: Type", "documentation": { "value": "Optional arguments accepted by the directive." } },
+        { "label": "on LOCATION", "documentation": { "value": "Schema locations where the directive can be applied (e.g., FIELD, OBJECT, ARGUMENT_DEFINITION)." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/hcl.json

@@ -0,0 +1,107 @@
+{
+  "language": "hcl",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "resource \"type\" \"name\" { ...config }",
+      "documentation": { "value": "Declares an infrastructure resource of the given type with configuration arguments." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The resource type (e.g., \"aws_instance\", \"azurerm_resource_group\")." } },
+        { "label": "name", "documentation": { "value": "A local name used to refer to this resource elsewhere in the configuration." } }
+      ]
+    },
+    {
+      "label": "variable \"name\" { type, default, description }",
+      "documentation": { "value": "Declares an input variable that can be set when applying the configuration." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the variable, used as var.<name> in expressions." } }
+      ]
+    },
+    {
+      "label": "output \"name\" { value, description }",
+      "documentation": { "value": "Declares an output value that is displayed after apply and accessible by other configurations." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the output value." } }
+      ]
+    },
+    {
+      "label": "data \"type\" \"name\" { ...query }",
+      "documentation": { "value": "Declares a data source to fetch information from an external source or another configuration." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The data source type (e.g., \"aws_ami\", \"azurerm_subscription\")." } },
+        { "label": "name", "documentation": { "value": "A local name for this data source." } }
+      ]
+    },
+    {
+      "label": "module \"name\" { source, ...inputs }",
+      "documentation": { "value": "Calls a child module with the given source and input variables." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "A local name for this module instance." } }
+      ]
+    },
+    {
+      "label": "locals { key = value, ... }",
+      "documentation": { "value": "Declares local values that can simplify expressions and avoid repetition within a module." },
+      "parameters": []
+    },
+    {
+      "label": "terraform { required_version, required_providers, backend }",
+      "documentation": { "value": "Configures Terraform behavior including version constraints, required providers, and backend state storage." },
+      "parameters": []
+    },
+    {
+      "label": "provider \"name\" { ...config }",
+      "documentation": { "value": "Configures a provider plugin with settings such as region, credentials, and other provider-specific options." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The provider name (e.g., \"aws\", \"azurerm\", \"google\")." } }
+      ]
+    },
+    {
+      "label": "lookup(map, key, default): value",
+      "documentation": { "value": "Retrieves a value from a map by its key, returning a default value if the key is not found." },
+      "parameters": [
+        { "label": "map", "documentation": { "value": "The map to look up the value in." } },
+        { "label": "key", "documentation": { "value": "The key to look up." } },
+        { "label": "default", "documentation": { "value": "The default value to return if the key is not found." } }
+      ]
+    },
+    {
+      "label": "element(list, index): value",
+      "documentation": { "value": "Retrieves a single element from a list by its index. The index is zero-based and wraps around using modulo." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The list to retrieve from." } },
+        { "label": "index", "documentation": { "value": "The zero-based index of the element." } }
+      ]
+    },
+    {
+      "label": "merge(maps...): map",
+      "documentation": { "value": "Takes an arbitrary number of maps or objects and returns a single map containing a merged set of elements from all arguments." },
+      "parameters": [
+        { "label": "maps...", "documentation": { "value": "One or more maps to merge. Later values override earlier ones for duplicate keys." } }
+      ]
+    },
+    {
+      "label": "concat(lists...): list",
+      "documentation": { "value": "Combines two or more lists into a single list." },
+      "parameters": [
+        { "label": "lists...", "documentation": { "value": "Two or more lists to concatenate in order." } }
+      ]
+    },
+    {
+      "label": "file(path): string",
+      "documentation": { "value": "Reads the contents of a file at the given path and returns it as a string." },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "The path to the file to read, relative to the root module directory." } }
+      ]
+    },
+    {
+      "label": "templatefile(path, vars): string",
+      "documentation": { "value": "Reads a file at the given path and renders its content as a template using the supplied variables." },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "The path to the template file." } },
+        { "label": "vars", "documentation": { "value": "A map of template variables to use during rendering." } }
+      ]
+    }
+  ]
+}