@enjoys/context-engine 1.1.1 → 1.2.0

package/data/signatureHelp/systemverilog.json

@@ -0,0 +1,116 @@
+{
+  "language": "systemverilog",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "$display(format: string, args: ...)",
+      "documentation": { "value": "Displays formatted text to the simulator console with an automatic newline." },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A format string with specifiers: `%d` decimal, `%h` hex, `%b` binary, `%s` string, `%t` time, `%m` module" } },
+        { "label": "args", "documentation": { "value": "Values to substitute into the format string" } }
+      ]
+    },
+    {
+      "label": "$write(format: string, args: ...)",
+      "documentation": { "value": "Displays formatted text to the simulator console without a trailing newline." },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A format string with specifiers" } },
+        { "label": "args", "documentation": { "value": "Values to substitute into the format string" } }
+      ]
+    },
+    {
+      "label": "$monitor(format: string, args: ...)",
+      "documentation": { "value": "Monitors and displays signal values whenever any of the listed signals change." },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A format string for display" } },
+        { "label": "args", "documentation": { "value": "Signals and values to monitor and display" } }
+      ]
+    },
+    {
+      "label": "$finish(n: integer)",
+      "documentation": { "value": "Terminates the simulation. The argument controls the diagnostic message level." },
+      "parameters": [
+        { "label": "n", "documentation": { "value": "Exit verbosity: `0` no message, `1` simulation time and location, `2` time, location, and statistics" } }
+      ]
+    },
+    {
+      "label": "$time(): time",
+      "documentation": { "value": "Returns the current simulation time as a 64-bit integer." },
+      "parameters": []
+    },
+    {
+      "label": "$random(seed: integer): integer",
+      "documentation": { "value": "Returns a 32-bit signed random integer. An optional seed controls the random sequence." },
+      "parameters": [
+        { "label": "seed", "documentation": { "value": "Optional seed variable for the random number generator" } }
+      ]
+    },
+    {
+      "label": "$readmemh(filename: string, memory: reg, start: integer, finish: integer)",
+      "documentation": { "value": "Reads hexadecimal values from a file and loads them into a memory array." },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "The path to the file containing hex data" } },
+        { "label": "memory", "documentation": { "value": "The memory array to load data into" } },
+        { "label": "start", "documentation": { "value": "Optional starting address" } },
+        { "label": "finish", "documentation": { "value": "Optional ending address" } }
+      ]
+    },
+    {
+      "label": "$readmemb(filename: string, memory: reg, start: integer, finish: integer)",
+      "documentation": { "value": "Reads binary values from a file and loads them into a memory array." },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "The path to the file containing binary data" } },
+        { "label": "memory", "documentation": { "value": "The memory array to load data into" } },
+        { "label": "start", "documentation": { "value": "Optional starting address" } },
+        { "label": "finish", "documentation": { "value": "Optional ending address" } }
+      ]
+    },
+    {
+      "label": "assert (expression) [else action_block]",
+      "documentation": { "value": "Checks that the given expression is true. If false, an assertion failure is reported." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A boolean expression that must be true" } },
+        { "label": "action_block", "documentation": { "value": "Optional action to execute on failure (e.g. `$error`, `$fatal`)" } }
+      ]
+    },
+    {
+      "label": "initial begin ... end",
+      "documentation": { "value": "Defines a block of statements that execute once at the beginning of simulation." },
+      "parameters": []
+    },
+    {
+      "label": "always @(sensitivity_list) begin ... end",
+      "documentation": { "value": "Defines a block that re-executes whenever a signal in the sensitivity list changes." },
+      "parameters": [
+        { "label": "sensitivity_list", "documentation": { "value": "Signals to trigger on: `posedge clk`, `negedge rst`, `*` for all, or combinational signals" } }
+      ]
+    },
+    {
+      "label": "module name #(parameters) (ports); ... endmodule",
+      "documentation": { "value": "Declares a hardware module with optional parameters and port declarations." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The module identifier" } },
+        { "label": "parameters", "documentation": { "value": "Optional parameter declarations for parameterized modules" } },
+        { "label": "ports", "documentation": { "value": "The module's input, output, and inout port declarations" } }
+      ]
+    },
+    {
+      "label": "function [automatic] return_type name(args); ... endfunction",
+      "documentation": { "value": "Declares a function that computes and returns a value in zero simulation time." },
+      "parameters": [
+        { "label": "return_type", "documentation": { "value": "The data type of the return value" } },
+        { "label": "name", "documentation": { "value": "The function identifier" } },
+        { "label": "args", "documentation": { "value": "Input arguments with their types" } }
+      ]
+    },
+    {
+      "label": "task [automatic] name(args); ... endtask",
+      "documentation": { "value": "Declares a task that can contain timing controls and does not return a value." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The task identifier" } },
+        { "label": "args", "documentation": { "value": "Input, output, and inout arguments" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/tcl.json

@@ -0,0 +1,139 @@
+{
+  "language": "tcl",
+  "triggerCharacters": [" ", "("],
+  "retriggerCharacters": [" "],
+  "signatures": [
+    {
+      "label": "puts ?-nonewline? ?channelId? string",
+      "documentation": { "value": "Writes string to channelId followed by a newline. Defaults to stdout." },
+      "parameters": [
+        { "label": "-nonewline", "documentation": { "value": "Optional flag to suppress the trailing newline" } },
+        { "label": "channelId", "documentation": { "value": "Optional output channel (default: stdout)" } },
+        { "label": "string", "documentation": { "value": "The string to write" } }
+      ]
+    },
+    {
+      "label": "set varName ?value?",
+      "documentation": { "value": "Assigns a value to a variable, or reads the variable's value if no value is given." },
+      "parameters": [
+        { "label": "varName", "documentation": { "value": "The name of the variable" } },
+        { "label": "value", "documentation": { "value": "Optional value to assign to the variable" } }
+      ]
+    },
+    {
+      "label": "expr expression",
+      "documentation": { "value": "Evaluates a mathematical or logical expression and returns the result." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A mathematical or logical expression using operators, functions, and variables" } }
+      ]
+    },
+    {
+      "label": "proc name args body",
+      "documentation": { "value": "Defines a new Tcl procedure (command) with the given name, argument list, and body." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the procedure" } },
+        { "label": "args", "documentation": { "value": "A list of argument specifications; use `{arg default}` for defaults, `args` for varargs" } },
+        { "label": "body", "documentation": { "value": "The Tcl script body of the procedure" } }
+      ]
+    },
+    {
+      "label": "if expr1 ?then? body1 ?elseif expr2 ?then? body2 ...? ?else? ?bodyN?",
+      "documentation": { "value": "Conditional execution. Evaluates the expression and executes the corresponding body." },
+      "parameters": [
+        { "label": "expr1", "documentation": { "value": "A boolean expression to test" } },
+        { "label": "body1", "documentation": { "value": "Script to execute when expr1 is true" } }
+      ]
+    },
+    {
+      "label": "foreach varname list body",
+      "documentation": { "value": "Iterates over each element of a list, assigning each to the variable and executing the body." },
+      "parameters": [
+        { "label": "varname", "documentation": { "value": "Variable to receive each element (or a list of variable names)" } },
+        { "label": "list", "documentation": { "value": "The list to iterate over" } },
+        { "label": "body", "documentation": { "value": "Script to execute for each element" } }
+      ]
+    },
+    {
+      "label": "while test body",
+      "documentation": { "value": "Repeatedly evaluates the test expression and executes the body while the test is true." },
+      "parameters": [
+        { "label": "test", "documentation": { "value": "A boolean expression evaluated before each iteration" } },
+        { "label": "body", "documentation": { "value": "Script to execute in each iteration" } }
+      ]
+    },
+    {
+      "label": "for start test next body",
+      "documentation": { "value": "A C-style for loop with initialization, test, increment, and body." },
+      "parameters": [
+        { "label": "start", "documentation": { "value": "Initialization script (executed once)" } },
+        { "label": "test", "documentation": { "value": "Boolean expression evaluated before each iteration" } },
+        { "label": "next", "documentation": { "value": "Script executed after each iteration (increment)" } },
+        { "label": "body", "documentation": { "value": "Script to execute in each iteration" } }
+      ]
+    },
+    {
+      "label": "switch ?options? string pattern body ?pattern body ...?",
+      "documentation": { "value": "Matches string against patterns and executes the body of the first match." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The string to match against patterns" } },
+        { "label": "pattern", "documentation": { "value": "A pattern to match (use `-exact`, `-glob`, or `-regexp` options)" } },
+        { "label": "body", "documentation": { "value": "Script to execute when the pattern matches" } }
+      ]
+    },
+    {
+      "label": "catch script ?resultVarName? ?optionsVarName?",
+      "documentation": { "value": "Evaluates the script and catches any errors. Returns the return code." },
+      "parameters": [
+        { "label": "script", "documentation": { "value": "The Tcl script to evaluate" } },
+        { "label": "resultVarName", "documentation": { "value": "Optional variable to store the result or error message" } },
+        { "label": "optionsVarName", "documentation": { "value": "Optional variable to store additional return options" } }
+      ]
+    },
+    {
+      "label": "string length string",
+      "documentation": { "value": "Returns the number of characters in the string." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The string to measure" } }
+      ]
+    },
+    {
+      "label": "string match ?-nocase? pattern string",
+      "documentation": { "value": "Tests whether the string matches the glob-style pattern." },
+      "parameters": [
+        { "label": "pattern", "documentation": { "value": "A glob pattern with `*`, `?`, and `[chars]` wildcards" } },
+        { "label": "string", "documentation": { "value": "The string to test against the pattern" } }
+      ]
+    },
+    {
+      "label": "lindex list ?index ...?",
+      "documentation": { "value": "Returns the element at the specified index from the list." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The list to index into" } },
+        { "label": "index", "documentation": { "value": "The 0-based index (or nested indices for sublists)" } }
+      ]
+    },
+    {
+      "label": "llength list",
+      "documentation": { "value": "Returns the number of elements in the list." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The list to count elements of" } }
+      ]
+    },
+    {
+      "label": "lappend varName ?value value ...?",
+      "documentation": { "value": "Appends values to the end of the list stored in the variable." },
+      "parameters": [
+        { "label": "varName", "documentation": { "value": "The variable containing the list" } },
+        { "label": "value", "documentation": { "value": "One or more values to append" } }
+      ]
+    },
+    {
+      "label": "lsort ?options? list",
+      "documentation": { "value": "Sorts the elements of a list and returns the sorted list." },
+      "parameters": [
+        { "label": "options", "documentation": { "value": "Sort options: `-ascii`, `-dictionary`, `-integer`, `-real`, `-increasing`, `-decreasing`, `-unique`" } },
+        { "label": "list", "documentation": { "value": "The list to sort" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/toml.json

@@ -0,0 +1,64 @@
+{
+  "language": "toml",
+  "triggerCharacters": ["=", "[", " "],
+  "retriggerCharacters": ["="],
+  "signatures": [
+    {
+      "label": "[table] - Standard table",
+      "documentation": { "value": "Defines a table (also called a hash table or dictionary). All key/value pairs that follow belong to this table until the next table header." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The table name, e.g. `[package]`, `[dependencies]`. Use dotted keys for nested tables: `[servers.alpha]`" } }
+      ]
+    },
+    {
+      "label": "[[array_of_tables]] - Array of tables",
+      "documentation": { "value": "Defines an array of tables. Each use of the same header creates a new element in the array." },
+      "parameters": [
+        { "label": "array_of_tables", "documentation": { "value": "The table name, e.g. `[[bin]]`, `[[test]]`. Each occurrence appends a new table to the array." } }
+      ]
+    },
+    {
+      "label": "key = value",
+      "documentation": { "value": "Assigns a value to a key. Keys are on the left of the equals sign and values are on the right." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "A bare key, quoted key, or dotted key, e.g. `name`, `\"quoted.key\"`, `server.host`" } },
+        { "label": "value", "documentation": { "value": "A string, integer, float, boolean, datetime, array, or inline table" } }
+      ]
+    },
+    {
+      "label": "inline_table = { key1 = val1, key2 = val2 }",
+      "documentation": { "value": "An inline table provides a compact syntax for expressing tables on a single line." },
+      "parameters": [
+        { "label": "key1 = val1", "documentation": { "value": "Comma-separated key/value pairs. Inline tables must appear on a single line." } }
+      ]
+    },
+    {
+      "label": "datetime = 1979-05-27T07:32:00Z",
+      "documentation": { "value": "TOML supports RFC 3339 datetimes: offset datetime, local datetime, local date, and local time." },
+      "parameters": [
+        { "label": "datetime", "documentation": { "value": "Formats: `1979-05-27T07:32:00Z` (offset), `1979-05-27T07:32:00` (local datetime), `1979-05-27` (local date), `07:32:00` (local time)" } }
+      ]
+    },
+    {
+      "label": "array = [val1, val2, val3]",
+      "documentation": { "value": "Arrays are square brackets with values inside. Whitespace is ignored. Values are separated by commas. Arrays can span multiple lines." },
+      "parameters": [
+        { "label": "val1, val2, val3", "documentation": { "value": "Array values. Can be mixed types in TOML v1.0+. A trailing comma is permitted." } }
+      ]
+    },
+    {
+      "label": "string = \"basic string\" | 'literal string'",
+      "documentation": { "value": "Basic strings use double quotes and support escape sequences. Literal strings use single quotes with no escaping. Multi-line variants use triple quotes." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "Basic: `\"hello\\nworld\"`, literal: `'C:\\path'`, multi-line basic: `\"\"\"...\"\"\"`, multi-line literal: `'''...'''`" } }
+      ]
+    },
+    {
+      "label": "boolean = true | false",
+      "documentation": { "value": "Booleans are lowercase `true` and `false`." },
+      "parameters": [
+        { "label": "true | false", "documentation": { "value": "Must be lowercase: `true` or `false`" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/twig.json

@@ -0,0 +1,120 @@
+{
+  "language": "twig",
+  "triggerCharacters": ["(", ",", " "],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "{{ expression }}",
+      "documentation": { "value": "Outputs the result of an expression. Variables, function calls, and filters can be used inside." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A Twig expression: variable, function call, or expression with filters" } }
+      ]
+    },
+    {
+      "label": "{% tag %} - Statement tag",
+      "documentation": { "value": "Executes statements such as control structures, variable assignments, and block definitions." },
+      "parameters": [
+        { "label": "tag", "documentation": { "value": "A Twig tag like `for`, `if`, `set`, `block`, `extends`, etc." } }
+      ]
+    },
+    {
+      "label": "{% block name %}content{% endblock %}",
+      "documentation": { "value": "Defines a named block that child templates can override. Used with template inheritance." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The block identifier" } },
+        { "label": "content", "documentation": { "value": "The default content of the block" } }
+      ]
+    },
+    {
+      "label": "{% extends 'template' %}",
+      "documentation": { "value": "Declares that the current template extends a parent template. Must be the first tag in the file." },
+      "parameters": [
+        { "label": "template", "documentation": { "value": "The path to the parent template" } }
+      ]
+    },
+    {
+      "label": "{% include 'template' with vars only %}",
+      "documentation": { "value": "Includes and renders another template within the current template." },
+      "parameters": [
+        { "label": "template", "documentation": { "value": "The path to the template to include" } },
+        { "label": "vars", "documentation": { "value": "Optional variables to pass to the included template" } },
+        { "label": "only", "documentation": { "value": "Optional keyword to restrict the included template to only the passed variables" } }
+      ]
+    },
+    {
+      "label": "{% for item in sequence %}...{% endfor %}",
+      "documentation": { "value": "Loops over each item in a sequence (array or iterable). Provides `loop` variable with index info." },
+      "parameters": [
+        { "label": "item", "documentation": { "value": "The variable name for the current element" } },
+        { "label": "sequence", "documentation": { "value": "The array, hash, or iterable to loop over" } }
+      ]
+    },
+    {
+      "label": "{% if condition %}...{% elseif condition %}...{% else %}...{% endif %}",
+      "documentation": { "value": "Conditional rendering of template content based on expression evaluation." },
+      "parameters": [
+        { "label": "condition", "documentation": { "value": "A Twig expression that evaluates to a truthy or falsy value" } }
+      ]
+    },
+    {
+      "label": "{% set variable = value %}",
+      "documentation": { "value": "Assigns a value to a variable inside the template." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The variable name to assign to" } },
+        { "label": "value", "documentation": { "value": "The expression or value to assign" } }
+      ]
+    },
+    {
+      "label": "{% macro name(arg1, arg2, ...) %}...{% endmacro %}",
+      "documentation": { "value": "Defines a reusable template fragment, similar to a function. Macros have their own scope." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The macro identifier" } },
+        { "label": "arg1, arg2", "documentation": { "value": "Parameters with optional default values" } }
+      ]
+    },
+    {
+      "label": "value|filter(args)",
+      "documentation": { "value": "Applies a filter to transform a value. Filters are separated from the variable by a pipe `|`." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to transform" } },
+        { "label": "filter", "documentation": { "value": "The filter name: `upper`, `lower`, `trim`, `slice`, `sort`, `join`, `replace`, etc." } },
+        { "label": "args", "documentation": { "value": "Optional arguments to pass to the filter" } }
+      ]
+    },
+    {
+      "label": "{% raw %}...{% endraw %}",
+      "documentation": { "value": "Prevents the Twig engine from processing the content inside the block. Outputs it as-is." },
+      "parameters": []
+    },
+    {
+      "label": "value|escape(strategy) or value|e(strategy)",
+      "documentation": { "value": "Escapes a string for safe output. Default strategy is `html`." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The string to escape" } },
+        { "label": "strategy", "documentation": { "value": "The escaping strategy: `html`, `js`, `css`, `url`, `html_attr`" } }
+      ]
+    },
+    {
+      "label": "value|date(format, timezone)",
+      "documentation": { "value": "Formats a date according to the given format string (uses PHP date format)." },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A PHP date format string, e.g. `'Y-m-d H:i:s'`" } },
+        { "label": "timezone", "documentation": { "value": "Optional timezone, e.g. `'Europe/Paris'`" } }
+      ]
+    },
+    {
+      "label": "value|format(args ...)",
+      "documentation": { "value": "Formats a string by replacing `%s` and `%d` placeholders (works like `sprintf`)." },
+      "parameters": [
+        { "label": "args", "documentation": { "value": "Values to substitute into the format placeholders" } }
+      ]
+    },
+    {
+      "label": "value|length: integer",
+      "documentation": { "value": "Returns the number of items in a sequence or the length of a string." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "A string, array, or countable object" } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/typescript.json

@@ -0,0 +1,135 @@
+{
+  "language": "typescript",
+  "triggerCharacters": ["(", ",", "<"],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "console.log(message?: any, ...optionalParams: any[]): void",
+      "documentation": { "value": "Prints a message to the console." },
+      "parameters": [
+        { "label": "message", "documentation": { "value": "The primary message or value to log" } },
+        { "label": "...optionalParams", "documentation": { "value": "Additional values to log, formatted using substitution strings if applicable" } }
+      ]
+    },
+    {
+      "label": "setTimeout(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout",
+      "documentation": { "value": "Schedules a function to be called after a specified delay in milliseconds." },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "The function to call after the timer elapses" } },
+        { "label": "ms", "documentation": { "value": "The delay in milliseconds (default: 0)" } },
+        { "label": "...args", "documentation": { "value": "Additional arguments to pass to the callback" } }
+      ]
+    },
+    {
+      "label": "setInterval(callback: (...args: any[]) => void, ms?: number, ...args: any[]): NodeJS.Timeout",
+      "documentation": { "value": "Repeatedly calls a function with a fixed time delay between each call." },
+      "parameters": [
+        { "label": "callback", "documentation": { "value": "The function to call repeatedly" } },
+        { "label": "ms", "documentation": { "value": "The interval in milliseconds between calls" } },
+        { "label": "...args", "documentation": { "value": "Additional arguments to pass to the callback" } }
+      ]
+    },
+    {
+      "label": "fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>",
+      "documentation": { "value": "Starts the process of fetching a resource from the network, returning a promise that resolves to the Response." },
+      "parameters": [
+        { "label": "input", "documentation": { "value": "The resource URL or a `Request` object" } },
+        { "label": "init", "documentation": { "value": "Optional request configuration: `method`, `headers`, `body`, `mode`, `credentials`, etc." } }
+      ]
+    },
+    {
+      "label": "JSON.stringify(value: any, replacer?: (key: string, value: any) => any | (string | number)[] | null, space?: string | number): string",
+      "documentation": { "value": "Converts a JavaScript value to a JSON string." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to convert to a JSON string" } },
+        { "label": "replacer", "documentation": { "value": "A function or array that transforms the results, or null" } },
+        { "label": "space", "documentation": { "value": "Indentation: a number of spaces or a string (up to 10 characters)" } }
+      ]
+    },
+    {
+      "label": "JSON.parse(text: string, reviver?: (key: string, value: any) => any): any",
+      "documentation": { "value": "Parses a JSON string and returns the resulting JavaScript value." },
+      "parameters": [
+        { "label": "text", "documentation": { "value": "The JSON string to parse" } },
+        { "label": "reviver", "documentation": { "value": "Optional function to transform each parsed key-value pair" } }
+      ]
+    },
+    {
+      "label": "Array<T>.map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[]",
+      "documentation": { "value": "Creates a new array populated with the results of calling a provided function on every element." },
+      "parameters": [
+        { "label": "callbackfn", "documentation": { "value": "A function called for every element: `(value, index, array) => newValue`" } },
+        { "label": "thisArg", "documentation": { "value": "Optional value to use as `this` when executing the callback" } }
+      ]
+    },
+    {
+      "label": "Array<T>.filter(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[]",
+      "documentation": { "value": "Creates a new array with all elements that pass the test implemented by the provided function." },
+      "parameters": [
+        { "label": "predicate", "documentation": { "value": "A function to test each element: `(value, index, array) => boolean`" } },
+        { "label": "thisArg", "documentation": { "value": "Optional value to use as `this` when executing the predicate" } }
+      ]
+    },
+    {
+      "label": "Array<T>.reduce<U>(callbackfn: (accumulator: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U",
+      "documentation": { "value": "Executes a reducer function on each element of the array, resulting in a single output value." },
+      "parameters": [
+        { "label": "callbackfn", "documentation": { "value": "A reducer function: `(accumulator, currentValue, currentIndex, array) => newAccumulator`" } },
+        { "label": "initialValue", "documentation": { "value": "The initial value for the accumulator" } }
+      ]
+    },
+    {
+      "label": "Promise.all<T>(values: Iterable<T | PromiseLike<T>>): Promise<Awaited<T>[]>",
+      "documentation": { "value": "Takes an iterable of promises and returns a single promise that resolves when all input promises resolve." },
+      "parameters": [
+        { "label": "values", "documentation": { "value": "An iterable of promises or values" } }
+      ]
+    },
+    {
+      "label": "Object.keys(o: object): string[]",
+      "documentation": { "value": "Returns an array of the given object's own enumerable string-keyed property names." },
+      "parameters": [
+        { "label": "o", "documentation": { "value": "The object whose property names to retrieve" } }
+      ]
+    },
+    {
+      "label": "Object.assign<T, U>(target: T, source: U): T & U",
+      "documentation": { "value": "Copies all enumerable own properties from one or more source objects to a target object and returns the target." },
+      "parameters": [
+        { "label": "target", "documentation": { "value": "The target object to copy properties to" } },
+        { "label": "source", "documentation": { "value": "One or more source objects to copy properties from" } }
+      ]
+    },
+    {
+      "label": "Record<Keys, Type>",
+      "documentation": { "value": "Constructs an object type whose property keys are `Keys` and whose property values are `Type`." },
+      "parameters": [
+        { "label": "Keys", "documentation": { "value": "The union of string literal types or `string` for the property keys" } },
+        { "label": "Type", "documentation": { "value": "The type of the property values" } }
+      ]
+    },
+    {
+      "label": "Partial<Type>",
+      "documentation": { "value": "Constructs a type with all properties of `Type` set to optional." },
+      "parameters": [
+        { "label": "Type", "documentation": { "value": "The type to make all properties optional" } }
+      ]
+    },
+    {
+      "label": "Pick<Type, Keys>",
+      "documentation": { "value": "Constructs a type by picking the specified set of properties from `Type`." },
+      "parameters": [
+        { "label": "Type", "documentation": { "value": "The type to pick properties from" } },
+        { "label": "Keys", "documentation": { "value": "The union of string literal types naming the properties to pick" } }
+      ]
+    },
+    {
+      "label": "Omit<Type, Keys>",
+      "documentation": { "value": "Constructs a type by picking all properties from `Type` and then removing `Keys`." },
+      "parameters": [
+        { "label": "Type", "documentation": { "value": "The source type" } },
+        { "label": "Keys", "documentation": { "value": "The union of string literal types naming the properties to omit" } }
+      ]
+    }
+  ]
+}