@enjoys/context-engine 1.1.2 → 1.3.1

package/data/signatureHelp/php.json

@@ -0,0 +1,137 @@
+{
+  "language": "php",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "echo(string ...$expressions): void",
+      "documentation": { "value": "Outputs one or more strings. Not actually a function but a language construct; parentheses are optional." },
+      "parameters": [
+        { "label": "$expressions", "documentation": { "value": "One or more string expressions to output." } }
+      ]
+    },
+    {
+      "label": "var_dump(mixed ...$values): void",
+      "documentation": { "value": "Dumps information about one or more variables, including type and value. Useful for debugging." },
+      "parameters": [
+        { "label": "$values", "documentation": { "value": "One or more variables to dump. Outputs type, length, and values recursively." } }
+      ]
+    },
+    {
+      "label": "print_r(mixed $value, bool $return = false): string|true",
+      "documentation": { "value": "Prints human-readable information about a variable. When $return is true, returns the output as a string." },
+      "parameters": [
+        { "label": "$value", "documentation": { "value": "The variable to print." } },
+        { "label": "$return", "documentation": { "value": "If true, returns the output as a string instead of printing it." } }
+      ]
+    },
+    {
+      "label": "array_map(?callable $callback, array $array, array ...$arrays): array",
+      "documentation": { "value": "Applies a callback function to each element of an array and returns a new array with the results." },
+      "parameters": [
+        { "label": "$callback", "documentation": { "value": "The callback function to apply. Receives array values as arguments. NULL creates an array of arrays." } },
+        { "label": "$array", "documentation": { "value": "The input array to map over." } },
+        { "label": "$arrays", "documentation": { "value": "Optional additional arrays. If passed, the callback receives corresponding elements from each." } }
+      ]
+    },
+    {
+      "label": "array_filter(array $array, ?callable $callback = null, int $mode = 0): array",
+      "documentation": { "value": "Filters elements of an array using a callback function. If no callback is supplied, removes falsy values." },
+      "parameters": [
+        { "label": "$array", "documentation": { "value": "The array to filter." } },
+        { "label": "$callback", "documentation": { "value": "The callback function. Return true to keep, false to remove." } },
+        { "label": "$mode", "documentation": { "value": "Flag: ARRAY_FILTER_USE_KEY (pass key), ARRAY_FILTER_USE_BOTH (pass value and key)." } }
+      ]
+    },
+    {
+      "label": "array_merge(array ...$arrays): array",
+      "documentation": { "value": "Merges one or more arrays. Values with numeric keys are renumbered; string keys are overwritten by later arrays." },
+      "parameters": [
+        { "label": "$arrays", "documentation": { "value": "The arrays to merge." } }
+      ]
+    },
+    {
+      "label": "array_push(array &$array, mixed ...$values): int",
+      "documentation": { "value": "Pushes one or more elements onto the end of an array. Returns the new number of elements." },
+      "parameters": [
+        { "label": "$array", "documentation": { "value": "The input array (passed by reference)." } },
+        { "label": "$values", "documentation": { "value": "The values to push." } }
+      ]
+    },
+    {
+      "label": "strlen(string $string): int",
+      "documentation": { "value": "Returns the length of a string in bytes." },
+      "parameters": [
+        { "label": "$string", "documentation": { "value": "The string to measure." } }
+      ]
+    },
+    {
+      "label": "strpos(string $haystack, string $needle, int $offset = 0): int|false",
+      "documentation": { "value": "Finds the position of the first occurrence of a substring. Returns false if not found." },
+      "parameters": [
+        { "label": "$haystack", "documentation": { "value": "The string to search in." } },
+        { "label": "$needle", "documentation": { "value": "The substring to search for." } },
+        { "label": "$offset", "documentation": { "value": "Optional starting position for the search." } }
+      ]
+    },
+    {
+      "label": "str_replace(array|string $search, array|string $replace, array|string $subject, int &$count = null): array|string",
+      "documentation": { "value": "Replaces all occurrences of the search string with the replacement string." },
+      "parameters": [
+        { "label": "$search", "documentation": { "value": "The value to search for (string or array of strings)." } },
+        { "label": "$replace", "documentation": { "value": "The replacement value (string or array of strings)." } },
+        { "label": "$subject", "documentation": { "value": "The string or array to perform replacements on." } },
+        { "label": "$count", "documentation": { "value": "Optional. Set to the number of replacements performed." } }
+      ]
+    },
+    {
+      "label": "preg_match(string $pattern, string $subject, array &$matches = null, int $flags = 0, int $offset = 0): int|false",
+      "documentation": { "value": "Performs a regular expression match. Returns 1 if matched, 0 if not, false on error." },
+      "parameters": [
+        { "label": "$pattern", "documentation": { "value": "The regex pattern to search for (e.g., '/\\d+/')." } },
+        { "label": "$subject", "documentation": { "value": "The input string to match against." } },
+        { "label": "$matches", "documentation": { "value": "Optional. Filled with the results of the match." } },
+        { "label": "$flags", "documentation": { "value": "Optional flags: PREG_OFFSET_CAPTURE, PREG_UNMATCHED_AS_NULL." } },
+        { "label": "$offset", "documentation": { "value": "Optional offset in bytes to start the search." } }
+      ]
+    },
+    {
+      "label": "json_encode(mixed $value, int $flags = 0, int $depth = 512): string|false",
+      "documentation": { "value": "Returns the JSON representation of a value." },
+      "parameters": [
+        { "label": "$value", "documentation": { "value": "The value to encode. Can be any type except a resource." } },
+        { "label": "$flags", "documentation": { "value": "Bitmask of JSON_* constants (e.g., JSON_PRETTY_PRINT, JSON_UNESCAPED_UNICODE)." } },
+        { "label": "$depth", "documentation": { "value": "Maximum nesting depth. Must be greater than zero." } }
+      ]
+    },
+    {
+      "label": "json_decode(string $json, ?bool $associative = null, int $depth = 512, int $flags = 0): mixed",
+      "documentation": { "value": "Decodes a JSON string into a PHP value." },
+      "parameters": [
+        { "label": "$json", "documentation": { "value": "The JSON string to decode." } },
+        { "label": "$associative", "documentation": { "value": "When true, JSON objects are returned as associative arrays instead of objects." } },
+        { "label": "$depth", "documentation": { "value": "Maximum nesting depth of the structure being decoded." } },
+        { "label": "$flags", "documentation": { "value": "Bitmask of JSON_* constants (e.g., JSON_BIGINT_AS_STRING, JSON_THROW_ON_ERROR)." } }
+      ]
+    },
+    {
+      "label": "file_get_contents(string $filename, bool $use_include_path = false, ?resource $context = null, int $offset = 0, ?int $length = null): string|false",
+      "documentation": { "value": "Reads the entire contents of a file into a string. Also supports reading from URLs via stream wrappers." },
+      "parameters": [
+        { "label": "$filename", "documentation": { "value": "The file path or URL to read." } },
+        { "label": "$use_include_path", "documentation": { "value": "Whether to search the include_path for the file." } },
+        { "label": "$context", "documentation": { "value": "A stream context resource created with stream_context_create()." } },
+        { "label": "$offset", "documentation": { "value": "The offset to start reading from in the original stream." } },
+        { "label": "$length", "documentation": { "value": "Maximum number of bytes to read." } }
+      ]
+    },
+    {
+      "label": "date(string $format, ?int $timestamp = null): string",
+      "documentation": { "value": "Formats a Unix timestamp (or the current time) according to the given format string." },
+      "parameters": [
+        { "label": "$format", "documentation": { "value": "The date format string (e.g., 'Y-m-d H:i:s', 'D, d M Y')." } },
+        { "label": "$timestamp", "documentation": { "value": "Optional Unix timestamp. Defaults to the current time." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/pla.json

@@ -0,0 +1,68 @@
+{
+  "language": "pla",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "DECLARE variable type",
+      "documentation": { "value": "Declares a variable with a specified type in PL/A." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The name of the variable to declare." } },
+        { "label": "type", "documentation": { "value": "The data type (e.g., FIXED, FLOAT, CHAR, BIT)." } }
+      ]
+    },
+    {
+      "label": "PUT LIST(expression, ...): void",
+      "documentation": { "value": "Outputs one or more expressions to the standard output stream in list-directed format." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression(s) to output." } }
+      ]
+    },
+    {
+      "label": "GET LIST(variable, ...): void",
+      "documentation": { "value": "Reads one or more values from the standard input stream in list-directed format." },
+      "parameters": [
+        { "label": "variable", "documentation": { "value": "The variable(s) to store input values." } }
+      ]
+    },
+    {
+      "label": "SUBSTR(string, position, length): CHAR",
+      "documentation": { "value": "Extracts a substring from a string starting at the given position." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The source string." } },
+        { "label": "position", "documentation": { "value": "The 1-based start position." } },
+        { "label": "length", "documentation": { "value": "The number of characters to extract." } }
+      ]
+    },
+    {
+      "label": "LENGTH(string): FIXED",
+      "documentation": { "value": "Returns the current length of a varying-length character string." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The string to measure." } }
+      ]
+    },
+    {
+      "label": "INDEX(string, substring): FIXED",
+      "documentation": { "value": "Returns the position of the first occurrence of a substring within a string. Returns 0 if not found." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The string to search in." } },
+        { "label": "substring", "documentation": { "value": "The substring to search for." } }
+      ]
+    },
+    {
+      "label": "ABS(expression): number",
+      "documentation": { "value": "Returns the absolute value of a numeric expression." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "A numeric expression." } }
+      ]
+    },
+    {
+      "label": "MOD(dividend, divisor): FIXED",
+      "documentation": { "value": "Returns the remainder of integer division." },
+      "parameters": [
+        { "label": "dividend", "documentation": { "value": "The number to divide." } },
+        { "label": "divisor", "documentation": { "value": "The number to divide by." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/postiats.json

@@ -0,0 +1,72 @@
+{
+  "language": "postiats",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "print(x: a): void",
+      "documentation": { "value": "Prints a value to standard output without a trailing newline." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "The value to print. Supports various types through overloading." } }
+      ]
+    },
+    {
+      "label": "println(x: a): void",
+      "documentation": { "value": "Prints a value to standard output followed by a newline character." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "The value to print followed by a newline." } }
+      ]
+    },
+    {
+      "label": "val name = expression",
+      "documentation": { "value": "Declares an immutable value binding. The pattern on the left is matched against the expression on the right." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name (or pattern) to bind." } },
+        { "label": "expression", "documentation": { "value": "The expression whose value is bound to the name." } }
+      ]
+    },
+    {
+      "label": "fun name(args): returnType = body",
+      "documentation": { "value": "Defines a function. Supports pattern matching, mutual recursion (with 'and'), and type annotations." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The function name." } },
+        { "label": "args", "documentation": { "value": "The function parameters with optional type annotations." } },
+        { "label": "returnType", "documentation": { "value": "The return type of the function." } },
+        { "label": "body", "documentation": { "value": "The function body expression." } }
+      ]
+    },
+    {
+      "label": "implement name(args) = body",
+      "documentation": { "value": "Provides the implementation for a previously declared function template." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name of the function to implement." } },
+        { "label": "args", "documentation": { "value": "The function arguments." } },
+        { "label": "body", "documentation": { "value": "The implementation body." } }
+      ]
+    },
+    {
+      "label": "extern fun name(args): returnType = \"external_name\"",
+      "documentation": { "value": "Declares an external function from C or another language for use in ATS." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The ATS name for the external function." } },
+        { "label": "args", "documentation": { "value": "Parameter types." } },
+        { "label": "returnType", "documentation": { "value": "The return type." } },
+        { "label": "external_name", "documentation": { "value": "The C function name string." } }
+      ]
+    },
+    {
+      "label": "staload \"filename\"",
+      "documentation": { "value": "Statically loads a file and brings its declarations into scope. Required for accessing types and functions." },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "The .sats or .hats file to load." } }
+      ]
+    },
+    {
+      "label": "dynload \"filename\"",
+      "documentation": { "value": "Dynamically loads a file to ensure its top-level definitions are initialized at runtime." },
+      "parameters": [
+        { "label": "filename", "documentation": { "value": "The .dats file to dynamically load." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/powerquery.json

@@ -0,0 +1,99 @@
+{
+  "language": "powerquery",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "Table.SelectRows(table as table, condition as function) as table",
+      "documentation": { "value": "Returns a table containing only the rows that match the specified condition function." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The input table to filter." } },
+        { "label": "condition", "documentation": { "value": "A function applied to each row. Returns true to include the row (e.g., each [Column] > 10)." } }
+      ]
+    },
+    {
+      "label": "Table.AddColumn(table as table, newColumnName as text, columnGenerator as function, optional columnType as type) as table",
+      "documentation": { "value": "Adds a new column to the table with values computed by the given function." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The input table." } },
+        { "label": "newColumnName", "documentation": { "value": "The name of the new column." } },
+        { "label": "columnGenerator", "documentation": { "value": "A function applied to each row to compute the new column value (e.g., each [A] + [B])." } },
+        { "label": "columnType", "documentation": { "value": "Optional. The type of the new column (e.g., type number, type text)." } }
+      ]
+    },
+    {
+      "label": "Table.TransformColumns(table as table, transformOperations as list, optional defaultTransformation as function, optional missingField as MissingField.Type) as table",
+      "documentation": { "value": "Transforms the values of one or more columns using the specified transformation functions." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The input table." } },
+        { "label": "transformOperations", "documentation": { "value": "A list of {column name, transformation function} pairs." } },
+        { "label": "defaultTransformation", "documentation": { "value": "Optional. A function to apply to columns not listed in transformOperations." } },
+        { "label": "missingField", "documentation": { "value": "Optional. Behavior when a column is missing: MissingField.Error, MissingField.Ignore, MissingField.UseNull." } }
+      ]
+    },
+    {
+      "label": "List.Select(list as list, selection as function) as list",
+      "documentation": { "value": "Returns a list of values from the input list that match the selection criteria." },
+      "parameters": [
+        { "label": "list", "documentation": { "value": "The input list to filter." } },
+        { "label": "selection", "documentation": { "value": "The condition function applied to each element (e.g., each _ > 5)." } }
+      ]
+    },
+    {
+      "label": "Text.Contains(text as nullable text, substring as text, optional comparer as Comparer.Type) as nullable logical",
+      "documentation": { "value": "Returns true if the text contains the specified substring." },
+      "parameters": [
+        { "label": "text", "documentation": { "value": "The text to search in." } },
+        { "label": "substring", "documentation": { "value": "The substring to search for." } },
+        { "label": "comparer", "documentation": { "value": "Optional. A comparer function (e.g., Comparer.OrdinalIgnoreCase for case-insensitive)." } }
+      ]
+    },
+    {
+      "label": "Number.Round(number as nullable number, optional digits as nullable number, optional roundingMode as nullable RoundingMode.Type) as nullable number",
+      "documentation": { "value": "Returns the result of rounding a number to the specified number of digits." },
+      "parameters": [
+        { "label": "number", "documentation": { "value": "The number to round." } },
+        { "label": "digits", "documentation": { "value": "Optional. The number of decimal places. Default is 0." } },
+        { "label": "roundingMode", "documentation": { "value": "Optional. RoundingMode.Up, RoundingMode.Down, RoundingMode.AwayFromZero, RoundingMode.ToEven." } }
+      ]
+    },
+    {
+      "label": "Date.From(value as any, optional culture as nullable text) as nullable date",
+      "documentation": { "value": "Converts a value to a date. Supports conversion from text, datetime, datetimezone, and number." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to convert to a date." } },
+        { "label": "culture", "documentation": { "value": "Optional. A text value for culture-specific parsing (e.g., \"en-US\")." } }
+      ]
+    },
+    {
+      "label": "Record.Field(record as record, field as text) as any",
+      "documentation": { "value": "Returns the value of the specified field in a record. Equivalent to record[field]." },
+      "parameters": [
+        { "label": "record", "documentation": { "value": "The record to access." } },
+        { "label": "field", "documentation": { "value": "The name of the field to retrieve." } }
+      ]
+    },
+    {
+      "label": "Table.Group(table as table, key as any, aggregatedColumns as list, optional groupKind as GroupKind.Type, optional comparer as function) as table",
+      "documentation": { "value": "Groups table rows by key columns and applies aggregate functions to create summary columns." },
+      "parameters": [
+        { "label": "table", "documentation": { "value": "The input table to group." } },
+        { "label": "key", "documentation": { "value": "The column name or list of column names to group by." } },
+        { "label": "aggregatedColumns", "documentation": { "value": "A list of {new column name, aggregation function, optional type} lists." } },
+        { "label": "groupKind", "documentation": { "value": "Optional. GroupKind.Global or GroupKind.Local." } },
+        { "label": "comparer", "documentation": { "value": "Optional. A comparer function for comparing key values." } }
+      ]
+    },
+    {
+      "label": "Table.Join(table1 as table, key1 as any, table2 as table, key2 as any, optional joinKind as JoinKind.Type, optional joinAlgorithm as JoinAlgorithm.Type, optional keyEqualityComparers as list) as table",
+      "documentation": { "value": "Joins two tables based on matching key columns." },
+      "parameters": [
+        { "label": "table1", "documentation": { "value": "The left table." } },
+        { "label": "key1", "documentation": { "value": "The join key column name(s) from table1." } },
+        { "label": "table2", "documentation": { "value": "The right table." } },
+        { "label": "key2", "documentation": { "value": "The join key column name(s) from table2." } },
+        { "label": "joinKind", "documentation": { "value": "Optional. JoinKind.Inner, JoinKind.LeftOuter, JoinKind.RightOuter, JoinKind.FullOuter, JoinKind.LeftAnti, JoinKind.RightAnti." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/powershell.json

@@ -0,0 +1,140 @@
+{
+  "language": "powershell",
+  "triggerCharacters": ["(", ",", " "],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "Write-Host [-Object] <Object> [-NoNewline] [-Separator <Object>] [-ForegroundColor <ConsoleColor>] [-BackgroundColor <ConsoleColor>]",
+      "documentation": { "value": "Writes customized output to the host (console). Supports colored text output. Note: output is not sent to the pipeline." },
+      "parameters": [
+        { "label": "-Object", "documentation": { "value": "The object to display. Can be a string, number, or any object." } },
+        { "label": "-NoNewline", "documentation": { "value": "Suppresses the newline at the end of the output." } },
+        { "label": "-ForegroundColor", "documentation": { "value": "Text color: Black, DarkBlue, DarkGreen, DarkCyan, DarkRed, DarkMagenta, DarkYellow, Gray, DarkGray, Blue, Green, Cyan, Red, Magenta, Yellow, White." } },
+        { "label": "-BackgroundColor", "documentation": { "value": "Background color. Same color options as ForegroundColor." } }
+      ]
+    },
+    {
+      "label": "Write-Output [-InputObject] <PSObject[]> [-NoEnumerate]",
+      "documentation": { "value": "Sends the specified objects to the next command in the pipeline. If it is the last command, the objects are displayed in the console." },
+      "parameters": [
+        { "label": "-InputObject", "documentation": { "value": "The objects to send through the pipeline." } },
+        { "label": "-NoEnumerate", "documentation": { "value": "By default, collections are enumerated. This switch suppresses that behavior." } }
+      ]
+    },
+    {
+      "label": "Get-ChildItem [[-Path] <String[]>] [[-Filter] <String>] [-Recurse] [-Include <String[]>] [-Exclude <String[]>] [-Force] [-Name]",
+      "documentation": { "value": "Gets the items and child items in one or more specified locations (files, folders, registry keys, etc.)." },
+      "parameters": [
+        { "label": "-Path", "documentation": { "value": "The path(s) to get child items from. Wildcards are permitted." } },
+        { "label": "-Filter", "documentation": { "value": "A filter in the provider's format (e.g., '*.txt'). More efficient than -Include." } },
+        { "label": "-Recurse", "documentation": { "value": "Gets items in all child containers (subdirectories)." } },
+        { "label": "-Include", "documentation": { "value": "String array of patterns to include (e.g., '*.log', '*.txt')." } },
+        { "label": "-Exclude", "documentation": { "value": "String array of patterns to exclude." } }
+      ]
+    },
+    {
+      "label": "Set-Location [[-Path] <String>] [-PassThru]",
+      "documentation": { "value": "Sets the current working location to a specified location (directory, registry key, etc.)." },
+      "parameters": [
+        { "label": "-Path", "documentation": { "value": "The path to the new location." } },
+        { "label": "-PassThru", "documentation": { "value": "Returns the PathInfo object representing the location." } }
+      ]
+    },
+    {
+      "label": "New-Object [-TypeName] <String> [[-ArgumentList] <Object[]>] [-Property <IDictionary>]",
+      "documentation": { "value": "Creates an instance of a .NET or COM object." },
+      "parameters": [
+        { "label": "-TypeName", "documentation": { "value": "The fully qualified name of the .NET class (e.g., 'System.Collections.ArrayList')." } },
+        { "label": "-ArgumentList", "documentation": { "value": "Arguments to pass to the constructor." } },
+        { "label": "-Property", "documentation": { "value": "A hashtable of property names and values to set on the new object." } }
+      ]
+    },
+    {
+      "label": "Invoke-WebRequest [-Uri] <Uri> [-Method <WebRequestMethod>] [-Body <Object>] [-Headers <IDictionary>] [-ContentType <String>] [-OutFile <String>]",
+      "documentation": { "value": "Sends an HTTP or HTTPS request to a web page or web service and parses the response." },
+      "parameters": [
+        { "label": "-Uri", "documentation": { "value": "The URI of the web resource to send the request to." } },
+        { "label": "-Method", "documentation": { "value": "The HTTP method: Default, Get, Head, Post, Put, Delete, Trace, Options, Merge, Patch." } },
+        { "label": "-Body", "documentation": { "value": "The body of the request. Can be a string, hashtable, or byte array." } },
+        { "label": "-Headers", "documentation": { "value": "A dictionary of additional HTTP headers." } },
+        { "label": "-ContentType", "documentation": { "value": "The content type of the request (e.g., 'application/json')." } },
+        { "label": "-OutFile", "documentation": { "value": "Saves the response body to the specified file." } }
+      ]
+    },
+    {
+      "label": "ConvertTo-Json [-InputObject] <Object> [-Depth <Int32>] [-Compress] [-EnumsAsStrings]",
+      "documentation": { "value": "Converts an object to a JSON-formatted string." },
+      "parameters": [
+        { "label": "-InputObject", "documentation": { "value": "The object to convert to JSON." } },
+        { "label": "-Depth", "documentation": { "value": "The maximum depth of nested objects to include. Default is 2." } },
+        { "label": "-Compress", "documentation": { "value": "Omits whitespace and indentation for a compact representation." } }
+      ]
+    },
+    {
+      "label": "ConvertFrom-Json [-InputObject] <String> [-AsHashtable] [-Depth <Int32>]",
+      "documentation": { "value": "Converts a JSON-formatted string to a PowerShell object (PSCustomObject or Hashtable)." },
+      "parameters": [
+        { "label": "-InputObject", "documentation": { "value": "The JSON string to convert." } },
+        { "label": "-AsHashtable", "documentation": { "value": "Converts JSON to a Hashtable instead of PSCustomObject." } },
+        { "label": "-Depth", "documentation": { "value": "Maximum depth the JSON input is allowed to have. Default is 1024." } }
+      ]
+    },
+    {
+      "label": "ForEach-Object [-Process] <ScriptBlock[]> [-InputObject <PSObject>] [-Begin <ScriptBlock>] [-End <ScriptBlock>]",
+      "documentation": { "value": "Performs an operation against each item in a collection of input objects." },
+      "parameters": [
+        { "label": "-Process", "documentation": { "value": "The script block to run for each input object. Use $_ or $PSItem for the current object." } },
+        { "label": "-InputObject", "documentation": { "value": "The input objects. Usually received from the pipeline." } },
+        { "label": "-Begin", "documentation": { "value": "Script block to run before processing any input objects." } },
+        { "label": "-End", "documentation": { "value": "Script block to run after processing all input objects." } }
+      ]
+    },
+    {
+      "label": "Where-Object [-FilterScript] <ScriptBlock> [-InputObject <PSObject>]",
+      "documentation": { "value": "Selects objects from a collection based on their property values." },
+      "parameters": [
+        { "label": "-FilterScript", "documentation": { "value": "The script block used to filter objects. Returns $true to include the object (e.g., { $_.Length -gt 100 })." } },
+        { "label": "-InputObject", "documentation": { "value": "The objects to filter. Usually received from the pipeline." } }
+      ]
+    },
+    {
+      "label": "Select-Object [[-Property] <Object[]>] [-First <Int32>] [-Last <Int32>] [-Skip <Int32>] [-Unique] [-ExpandProperty <String>]",
+      "documentation": { "value": "Selects specified properties of objects or a specified number of objects." },
+      "parameters": [
+        { "label": "-Property", "documentation": { "value": "The property names to select (e.g., Name, Length, @{Name='Size';Expression={$_.Length}})." } },
+        { "label": "-First", "documentation": { "value": "Number of objects to select from the beginning." } },
+        { "label": "-Last", "documentation": { "value": "Number of objects to select from the end." } },
+        { "label": "-ExpandProperty", "documentation": { "value": "A property to expand (select all items in the property's collection)." } }
+      ]
+    },
+    {
+      "label": "Sort-Object [[-Property] <Object[]>] [-Descending] [-Unique] [-CaseSensitive]",
+      "documentation": { "value": "Sorts objects by property values." },
+      "parameters": [
+        { "label": "-Property", "documentation": { "value": "The property or properties to sort by." } },
+        { "label": "-Descending", "documentation": { "value": "Sorts in descending order." } },
+        { "label": "-Unique", "documentation": { "value": "Eliminates duplicates and returns only unique members." } }
+      ]
+    },
+    {
+      "label": "Test-Path [-Path] <String[]> [-PathType <TestPathType>] [-IsValid]",
+      "documentation": { "value": "Determines whether all elements of a path exist. Returns $true or $false." },
+      "parameters": [
+        { "label": "-Path", "documentation": { "value": "The path to test. Wildcards are permitted." } },
+        { "label": "-PathType", "documentation": { "value": "The type of element to test: Any, Container (directory), Leaf (file)." } },
+        { "label": "-IsValid", "documentation": { "value": "Tests whether the path syntax is valid, regardless of whether the path exists." } }
+      ]
+    },
+    {
+      "label": "Get-Content [-Path] <String[]> [-TotalCount <Int64>] [-Tail <Int32>] [-Encoding <Encoding>] [-Raw]",
+      "documentation": { "value": "Gets the content of a file as an array of strings (one per line) or as a single string with -Raw." },
+      "parameters": [
+        { "label": "-Path", "documentation": { "value": "The path to the file(s) to read." } },
+        { "label": "-TotalCount", "documentation": { "value": "Read only the first N lines." } },
+        { "label": "-Tail", "documentation": { "value": "Read only the last N lines." } },
+        { "label": "-Encoding", "documentation": { "value": "The encoding: ASCII, UTF8, UTF7, UTF32, Unicode, BigEndianUnicode, Default, OEM." } },
+        { "label": "-Raw", "documentation": { "value": "Returns the entire file as a single string instead of an array of lines." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/protobuf.json

@@ -0,0 +1,105 @@
+{
+  "language": "protobuf",
+  "triggerCharacters": ["(", ",", " "],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "message MessageName { field_type field_name = field_number; }",
+      "documentation": { "value": "Defines a message type, the fundamental unit of data in Protocol Buffers. Messages contain typed fields with unique numeric tags." },
+      "parameters": [
+        { "label": "MessageName", "documentation": { "value": "The name of the message type, in CamelCase by convention." } },
+        { "label": "field_type field_name = field_number", "documentation": { "value": "Field definitions with type, name, and unique tag number (1-536870911, excluding 19000-19999)." } }
+      ]
+    },
+    {
+      "label": "service ServiceName { rpc MethodName (RequestType) returns (ResponseType); }",
+      "documentation": { "value": "Defines an RPC service with method signatures. Used by gRPC and other RPC frameworks." },
+      "parameters": [
+        { "label": "ServiceName", "documentation": { "value": "The name of the service." } },
+        { "label": "rpc MethodName", "documentation": { "value": "The RPC method declarations within the service." } }
+      ]
+    },
+    {
+      "label": "rpc MethodName (RequestType) returns (ResponseType)",
+      "documentation": { "value": "Defines an RPC method within a service. Supports unary and streaming (stream keyword) calls." },
+      "parameters": [
+        { "label": "MethodName", "documentation": { "value": "The name of the RPC method." } },
+        { "label": "RequestType", "documentation": { "value": "The request message type. Prefix with 'stream' for client streaming." } },
+        { "label": "ResponseType", "documentation": { "value": "The response message type. Prefix with 'stream' for server streaming." } }
+      ]
+    },
+    {
+      "label": "enum EnumName { ENUM_VALUE = 0; ENUM_VALUE2 = 1; }",
+      "documentation": { "value": "Defines an enumeration type. The first value must be zero and serves as the default." },
+      "parameters": [
+        { "label": "EnumName", "documentation": { "value": "The name of the enum type, in CamelCase." } },
+        { "label": "ENUM_VALUE = number", "documentation": { "value": "Enum values with unique numeric assignments. First value must be 0." } }
+      ]
+    },
+    {
+      "label": "oneof oneof_name { type1 field1 = tag1; type2 field2 = tag2; }",
+      "documentation": { "value": "Specifies that at most one of the fields in the group will be set at a time. Setting one field clears the others." },
+      "parameters": [
+        { "label": "oneof_name", "documentation": { "value": "The name of the oneof group." } },
+        { "label": "fields", "documentation": { "value": "The mutually exclusive field definitions. Cannot contain map or repeated fields." } }
+      ]
+    },
+    {
+      "label": "map<key_type, value_type> field_name = field_number",
+      "documentation": { "value": "Defines a map field. Key types can be any integral or string type. Value types can be any type except another map." },
+      "parameters": [
+        { "label": "key_type", "documentation": { "value": "The key type: int32, int64, uint32, uint64, sint32, sint64, fixed32, fixed64, sfixed32, sfixed64, bool, string." } },
+        { "label": "value_type", "documentation": { "value": "The value type: any scalar, enum, or message type." } },
+        { "label": "field_name", "documentation": { "value": "The name of the map field." } },
+        { "label": "field_number", "documentation": { "value": "The unique field tag number." } }
+      ]
+    },
+    {
+      "label": "repeated type field_name = field_number",
+      "documentation": { "value": "Defines a repeated field (array/list). Can contain zero or more values of the specified type." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The element type (any scalar, enum, or message type)." } },
+        { "label": "field_name", "documentation": { "value": "The name of the repeated field." } },
+        { "label": "field_number", "documentation": { "value": "The unique field tag number." } }
+      ]
+    },
+    {
+      "label": "optional type field_name = field_number",
+      "documentation": { "value": "Defines an optional field (proto3). Enables explicit presence tracking so you can distinguish between default and unset." },
+      "parameters": [
+        { "label": "type", "documentation": { "value": "The field type." } },
+        { "label": "field_name", "documentation": { "value": "The name of the field." } },
+        { "label": "field_number", "documentation": { "value": "The unique field tag number." } }
+      ]
+    },
+    {
+      "label": "package package.name",
+      "documentation": { "value": "Specifies the package namespace for the .proto file. Prevents naming conflicts between message types." },
+      "parameters": [
+        { "label": "package.name", "documentation": { "value": "The package name, typically using dot-separated notation (e.g., com.example.project)." } }
+      ]
+    },
+    {
+      "label": "import \"path/to/file.proto\"",
+      "documentation": { "value": "Imports definitions from another .proto file. Use 'import public' to transitively expose imports." },
+      "parameters": [
+        { "label": "path/to/file.proto", "documentation": { "value": "The path to the .proto file to import, relative to the proto path." } }
+      ]
+    },
+    {
+      "label": "syntax = \"proto3\"",
+      "documentation": { "value": "Specifies the Protocol Buffers syntax version. Must be the first non-comment line. Options: 'proto2' or 'proto3'." },
+      "parameters": [
+        { "label": "version", "documentation": { "value": "The syntax version: 'proto2' or 'proto3'." } }
+      ]
+    },
+    {
+      "label": "option option_name = value",
+      "documentation": { "value": "Sets a file-level, message-level, or field-level option. Common options include java_package, go_package, optimize_for." },
+      "parameters": [
+        { "label": "option_name", "documentation": { "value": "The option name (e.g., java_package, go_package, optimize_for, deprecated)." } },
+        { "label": "value", "documentation": { "value": "The option value (string, integer, or identifier)." } }
+      ]
+    }
+  ]
+}