@enjoys/context-engine 1.1.2 → 1.3.1

package/data/signatureHelp/nginx.json

@@ -0,0 +1,95 @@
+{
+  "language": "nginx",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "server { listen, server_name, root, location }",
+      "documentation": { "value": "Defines a virtual server configuration block that handles requests for a specific domain or IP." },
+      "parameters": [
+        { "label": "listen", "documentation": { "value": "The address and port to listen on (e.g., 80, 443 ssl, [::]:80)." } },
+        { "label": "server_name", "documentation": { "value": "The domain names this server block responds to." } }
+      ]
+    },
+    {
+      "label": "location uri { ... }",
+      "documentation": { "value": "Sets configuration for a specific request URI. Supports exact match (=), prefix, and regex (~, ~*) matching." },
+      "parameters": [
+        { "label": "uri", "documentation": { "value": "The URI pattern to match. Prefixes: = (exact), ~ (case-sensitive regex), ~* (case-insensitive regex), ^~ (prefix priority)." } }
+      ]
+    },
+    {
+      "label": "proxy_pass url",
+      "documentation": { "value": "Sets the protocol, address, and URI of a proxied server. Used to forward requests to backend servers." },
+      "parameters": [
+        { "label": "url", "documentation": { "value": "The upstream URL (e.g., http://backend:8080, http://unix:/tmp/sock.sock)." } }
+      ]
+    },
+    {
+      "label": "listen address[:port] [ssl] [http2] [default_server]",
+      "documentation": { "value": "Sets the address and port on which the server will accept requests." },
+      "parameters": [
+        { "label": "address[:port]", "documentation": { "value": "The IP address and/or port to listen on (e.g., 80, 127.0.0.1:8080, [::]:443)." } },
+        { "label": "ssl", "documentation": { "value": "Optional. Enables SSL/TLS for this listening socket." } },
+        { "label": "default_server", "documentation": { "value": "Optional. Makes this the default server for the address:port pair." } }
+      ]
+    },
+    {
+      "label": "root path",
+      "documentation": { "value": "Sets the root directory for serving files. The full file path is constructed by appending the URI to the root." },
+      "parameters": [
+        { "label": "path", "documentation": { "value": "The filesystem path to serve files from (e.g., /var/www/html)." } }
+      ]
+    },
+    {
+      "label": "index file1 [file2 ...]",
+      "documentation": { "value": "Defines files that will be used as an index when a directory is requested." },
+      "parameters": [
+        { "label": "file1", "documentation": { "value": "The primary index file (e.g., index.html)." } },
+        { "label": "file2", "documentation": { "value": "Optional fallback index file (e.g., index.htm, index.php)." } }
+      ]
+    },
+    {
+      "label": "ssl_certificate file",
+      "documentation": { "value": "Specifies the path to the PEM-format SSL/TLS certificate file for the server." },
+      "parameters": [
+        { "label": "file", "documentation": { "value": "Path to the certificate file (e.g., /etc/ssl/certs/server.crt)." } }
+      ]
+    },
+    {
+      "label": "upstream name { server address; }",
+      "documentation": { "value": "Defines a group of backend servers for load balancing." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The name used to reference this upstream group in proxy_pass." } },
+        { "label": "server address", "documentation": { "value": "Backend server address with optional parameters (weight, max_fails, fail_timeout)." } }
+      ]
+    },
+    {
+      "label": "rewrite regex replacement [flag]",
+      "documentation": { "value": "Rewrites the request URI using a regular expression. If the replacement starts with http://, the client gets a redirect." },
+      "parameters": [
+        { "label": "regex", "documentation": { "value": "The regular expression to match against the request URI." } },
+        { "label": "replacement", "documentation": { "value": "The replacement string. Can use captured groups ($1, $2, etc.)." } },
+        { "label": "flag", "documentation": { "value": "Optional flag: last (stop and re-search), break (stop), redirect (302), permanent (301)." } }
+      ]
+    },
+    {
+      "label": "add_header name value [always]",
+      "documentation": { "value": "Adds a custom header to the response. Headers are only added when the response code is 2xx or 3xx unless 'always' is specified." },
+      "parameters": [
+        { "label": "name", "documentation": { "value": "The header name (e.g., X-Frame-Options, Cache-Control)." } },
+        { "label": "value", "documentation": { "value": "The header value." } },
+        { "label": "always", "documentation": { "value": "Optional. If present, the header is added regardless of response code." } }
+      ]
+    },
+    {
+      "label": "try_files file1 [file2 ...] uri",
+      "documentation": { "value": "Checks for the existence of files in order and uses the first found. The last parameter is a fallback URI or =code." },
+      "parameters": [
+        { "label": "file1", "documentation": { "value": "The first file path to check (e.g., $uri)." } },
+        { "label": "file2", "documentation": { "value": "Additional file paths to try (e.g., $uri/)." } },
+        { "label": "uri", "documentation": { "value": "The fallback URI or error code (e.g., /index.html, =404)." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/objective-c.json

@@ -0,0 +1,78 @@
+{
+  "language": "objective-c",
+  "triggerCharacters": ["(", ",", ":"],
+  "retriggerCharacters": [",", ":"],
+  "signatures": [
+    {
+      "label": "NSLog(format, ...): void",
+      "documentation": { "value": "Logs an error message to the Apple System Log facility. Uses printf-style format specifiers with %@ for objects." },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "An NSString format string (e.g., @\"Value: %@, Count: %d\")." } },
+        { "label": "...", "documentation": { "value": "Variable arguments matching the format specifiers." } }
+      ]
+    },
+    {
+      "label": "[NSString stringWithFormat:(NSString *)format, ...]: NSString *",
+      "documentation": { "value": "Returns a string created by using a given format string as a template into which the remaining argument values are substituted." },
+      "parameters": [
+        { "label": "format", "documentation": { "value": "A format string. Uses %@ for objects, %d for integers, %f for floats, etc." } },
+        { "label": "...", "documentation": { "value": "A comma-separated list of arguments to substitute into the format string." } }
+      ]
+    },
+    {
+      "label": "[NSArray arrayWithObjects:(id)firstObj, ..., nil]: NSArray *",
+      "documentation": { "value": "Creates and returns an array containing the objects in the argument list. The list must be nil-terminated." },
+      "parameters": [
+        { "label": "firstObj", "documentation": { "value": "The first object to include in the array." } },
+        { "label": "...", "documentation": { "value": "Additional objects, followed by nil to terminate the list." } }
+      ]
+    },
+    {
+      "label": "[NSDictionary dictionaryWithObjectsAndKeys:(id)firstObject, (id)firstKey, ..., nil]: NSDictionary *",
+      "documentation": { "value": "Creates a dictionary with object-key pairs from the argument list. Must be nil-terminated." },
+      "parameters": [
+        { "label": "firstObject", "documentation": { "value": "The value for the first key." } },
+        { "label": "firstKey", "documentation": { "value": "The key for the first object." } },
+        { "label": "...", "documentation": { "value": "Additional value-key pairs, terminated with nil." } }
+      ]
+    },
+    {
+      "label": "[[ClassName alloc] init]: instancetype",
+      "documentation": { "value": "Allocates memory for a new object and initializes it. The standard two-step Objective-C object creation pattern." },
+      "parameters": [
+        { "label": "ClassName", "documentation": { "value": "The class to instantiate." } }
+      ]
+    },
+    {
+      "label": "[UIView initWithFrame:(CGRect)frame]: instancetype",
+      "documentation": { "value": "Initializes and returns a newly allocated UIView object with the specified frame rectangle." },
+      "parameters": [
+        { "label": "frame", "documentation": { "value": "The frame rectangle (CGRect) for the view, specifying origin and size in the superview's coordinate system." } }
+      ]
+    },
+    {
+      "label": "[UIView addSubview:(UIView *)view]: void",
+      "documentation": { "value": "Adds a view to the end of the receiver's list of subviews." },
+      "parameters": [
+        { "label": "view", "documentation": { "value": "The view to add as a subview. It is retained by the receiver." } }
+      ]
+    },
+    {
+      "label": "[NSObject performSelector:(SEL)aSelector withObject:(id)anArgument afterDelay:(NSTimeInterval)delay]: void",
+      "documentation": { "value": "Invokes a method of the receiver on the current thread after a specified delay." },
+      "parameters": [
+        { "label": "aSelector", "documentation": { "value": "A selector identifying the method to invoke. The method should take one or no arguments." } },
+        { "label": "anArgument", "documentation": { "value": "The argument to pass to the method. Pass nil if the method takes no arguments." } },
+        { "label": "delay", "documentation": { "value": "The minimum time before the message is sent, in seconds." } }
+      ]
+    },
+    {
+      "label": "dispatch_async(queue, block): void",
+      "documentation": { "value": "Submits a block for asynchronous execution on a dispatch queue and returns immediately." },
+      "parameters": [
+        { "label": "queue", "documentation": { "value": "The dispatch queue to submit the block to (e.g., dispatch_get_main_queue(), dispatch_get_global_queue())." } },
+        { "label": "block", "documentation": { "value": "The block to execute asynchronously. It takes no arguments and has no return value." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/pascal.json

@@ -0,0 +1,114 @@
+{
+  "language": "pascal",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "WriteLn(args: ...): void",
+      "documentation": { "value": "Writes one or more values to standard output followed by a newline character." },
+      "parameters": [
+        { "label": "args", "documentation": { "value": "One or more expressions to write. Supports strings, integers, reals, booleans, and chars." } }
+      ]
+    },
+    {
+      "label": "ReadLn(var s: string): void",
+      "documentation": { "value": "Reads a line of text from standard input into a variable." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The variable to store the input. Reads until end of line." } }
+      ]
+    },
+    {
+      "label": "Length(s: string): Integer",
+      "documentation": { "value": "Returns the number of characters in a string or elements in a dynamic array." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string or dynamic array whose length is returned." } }
+      ]
+    },
+    {
+      "label": "Copy(s: string, index: Integer, count: Integer): string",
+      "documentation": { "value": "Returns a substring of a string, starting at the given index for the given number of characters." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The source string." } },
+        { "label": "index", "documentation": { "value": "The 1-based starting position." } },
+        { "label": "count", "documentation": { "value": "The number of characters to copy." } }
+      ]
+    },
+    {
+      "label": "Pos(substr: string, s: string): Integer",
+      "documentation": { "value": "Returns the position of the first occurrence of a substring in a string. Returns 0 if not found." },
+      "parameters": [
+        { "label": "substr", "documentation": { "value": "The substring to search for." } },
+        { "label": "s", "documentation": { "value": "The string to search in." } }
+      ]
+    },
+    {
+      "label": "Delete(var s: string, index: Integer, count: Integer): void",
+      "documentation": { "value": "Removes count characters from string s starting at position index." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string to modify (passed by reference)." } },
+        { "label": "index", "documentation": { "value": "The 1-based starting position to delete from." } },
+        { "label": "count", "documentation": { "value": "The number of characters to delete." } }
+      ]
+    },
+    {
+      "label": "Insert(source: string, var s: string, index: Integer): void",
+      "documentation": { "value": "Inserts a substring into a string at the specified position." },
+      "parameters": [
+        { "label": "source", "documentation": { "value": "The substring to insert." } },
+        { "label": "s", "documentation": { "value": "The target string to insert into (passed by reference)." } },
+        { "label": "index", "documentation": { "value": "The 1-based position where the source string will be inserted." } }
+      ]
+    },
+    {
+      "label": "IntToStr(value: Integer): string",
+      "documentation": { "value": "Converts an integer value to its string representation." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The integer value to convert." } }
+      ]
+    },
+    {
+      "label": "StrToInt(s: string): Integer",
+      "documentation": { "value": "Converts a string to an integer value. Raises an exception if the string is not a valid integer." },
+      "parameters": [
+        { "label": "s", "documentation": { "value": "The string containing an integer representation." } }
+      ]
+    },
+    {
+      "label": "Concat(s1: string, s2: string, ...): string",
+      "documentation": { "value": "Concatenates two or more strings and returns the result." },
+      "parameters": [
+        { "label": "s1", "documentation": { "value": "The first string." } },
+        { "label": "s2", "documentation": { "value": "The second string." } },
+        { "label": "...", "documentation": { "value": "Additional strings to concatenate." } }
+      ]
+    },
+    {
+      "label": "Ord(c: Char): Integer",
+      "documentation": { "value": "Returns the ordinal (ASCII) value of a character." },
+      "parameters": [
+        { "label": "c", "documentation": { "value": "The character whose ordinal value is returned." } }
+      ]
+    },
+    {
+      "label": "Chr(x: Integer): Char",
+      "documentation": { "value": "Returns the character corresponding to the specified ASCII value." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "An integer value representing the ASCII code (0-255)." } }
+      ]
+    },
+    {
+      "label": "Abs(x: number): number",
+      "documentation": { "value": "Returns the absolute value of a numeric expression." },
+      "parameters": [
+        { "label": "x", "documentation": { "value": "An integer or real number." } }
+      ]
+    },
+    {
+      "label": "Random(range: Integer): Integer",
+      "documentation": { "value": "Returns a random integer between 0 and range-1. Call Randomize first to seed the generator." },
+      "parameters": [
+        { "label": "range", "documentation": { "value": "The upper bound (exclusive). If omitted, returns a real number between 0.0 and 1.0." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/pascaligo.json

@@ -0,0 +1,77 @@
+{
+  "language": "pascaligo",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "Map.find_opt(key: 'key, map: map('key, 'value)): option('value)",
+      "documentation": { "value": "Returns the value associated with a key in the map as Some(value), or None if the key is not present." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to look up in the map." } },
+        { "label": "map", "documentation": { "value": "The map to search in." } }
+      ]
+    },
+    {
+      "label": "Map.update(key: 'key, value: option('value), map: map('key, 'value)): map('key, 'value)",
+      "documentation": { "value": "Updates the value associated with a key. If value is Some(v), the binding is updated; if None, the key is removed." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to update." } },
+        { "label": "value", "documentation": { "value": "Some(new_value) to set, or None to remove the binding." } },
+        { "label": "map", "documentation": { "value": "The map to update." } }
+      ]
+    },
+    {
+      "label": "Map.mem(key: 'key, map: map('key, 'value)): bool",
+      "documentation": { "value": "Tests whether a key exists in the map. Returns true if the key is present." },
+      "parameters": [
+        { "label": "key", "documentation": { "value": "The key to test for membership." } },
+        { "label": "map", "documentation": { "value": "The map to test." } }
+      ]
+    },
+    {
+      "label": "List.map(f: ('a -> 'b), list: list('a)): list('b)",
+      "documentation": { "value": "Applies a function to each element of a list and returns a new list with the results." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The function to apply to each element." } },
+        { "label": "list", "documentation": { "value": "The input list." } }
+      ]
+    },
+    {
+      "label": "List.fold(f: (('acc, 'a) -> 'acc), list: list('a), init: 'acc): 'acc",
+      "documentation": { "value": "Reduces a list to a single value by applying a function to each element and an accumulator." },
+      "parameters": [
+        { "label": "f", "documentation": { "value": "The folding function that takes an accumulator and an element." } },
+        { "label": "list", "documentation": { "value": "The list to fold over." } },
+        { "label": "init", "documentation": { "value": "The initial accumulator value." } }
+      ]
+    },
+    {
+      "label": "Tezos.transaction(parameter: 'param, amount: tez, contract: contract('param)): operation",
+      "documentation": { "value": "Creates a transaction operation to send tokens to a contract with a parameter." },
+      "parameters": [
+        { "label": "parameter", "documentation": { "value": "The parameter to pass to the destination contract's entrypoint." } },
+        { "label": "amount", "documentation": { "value": "The amount of tez to transfer." } },
+        { "label": "contract", "documentation": { "value": "The target contract handle." } }
+      ]
+    },
+    {
+      "label": "Tezos.get_sender(): address",
+      "documentation": { "value": "Returns the address of the account that initiated the current transaction (may differ from source)." },
+      "parameters": []
+    },
+    {
+      "label": "abs(value: int): nat",
+      "documentation": { "value": "Returns the absolute value of an integer as a natural number (nat)." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The integer value to take the absolute value of." } }
+      ]
+    },
+    {
+      "label": "int(value: nat): int",
+      "documentation": { "value": "Converts a natural number (nat) to an integer." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The natural number to convert to int." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/perl.json

@@ -0,0 +1,132 @@
+{
+  "language": "perl",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "print(LIST): Boolean",
+      "documentation": { "value": "Prints a string or a list of strings to the selected output handle (default STDOUT). Returns true on success." },
+      "parameters": [
+        { "label": "LIST", "documentation": { "value": "A list of strings to print. Without arguments, prints $_." } }
+      ]
+    },
+    {
+      "label": "chomp(STRING): Integer",
+      "documentation": { "value": "Removes the trailing newline from a string (if present). Returns the number of characters removed." },
+      "parameters": [
+        { "label": "STRING", "documentation": { "value": "The string or variable to remove the trailing newline from. Modifies the variable in-place." } }
+      ]
+    },
+    {
+      "label": "split(PATTERN, STRING, LIMIT): List",
+      "documentation": { "value": "Splits a string into a list of substrings based on a delimiter pattern." },
+      "parameters": [
+        { "label": "PATTERN", "documentation": { "value": "The regex pattern or string delimiter to split on (e.g., /,/, /\\s+/)." } },
+        { "label": "STRING", "documentation": { "value": "The string to split. Defaults to $_ if omitted." } },
+        { "label": "LIMIT", "documentation": { "value": "Optional maximum number of fields. If negative, treated as arbitrarily large." } }
+      ]
+    },
+    {
+      "label": "join(SEPARATOR, LIST): String",
+      "documentation": { "value": "Joins the elements of a list into a single string with the specified separator." },
+      "parameters": [
+        { "label": "SEPARATOR", "documentation": { "value": "The string to place between each element." } },
+        { "label": "LIST", "documentation": { "value": "The list of values to join." } }
+      ]
+    },
+    {
+      "label": "push(@ARRAY, LIST): Integer",
+      "documentation": { "value": "Appends one or more values to the end of an array. Returns the new number of elements." },
+      "parameters": [
+        { "label": "@ARRAY", "documentation": { "value": "The array to append to." } },
+        { "label": "LIST", "documentation": { "value": "The values to push onto the array." } }
+      ]
+    },
+    {
+      "label": "pop(@ARRAY): Scalar",
+      "documentation": { "value": "Removes and returns the last element of an array, shortening the array by one." },
+      "parameters": [
+        { "label": "@ARRAY", "documentation": { "value": "The array to pop from. Defaults to @_ inside subroutines." } }
+      ]
+    },
+    {
+      "label": "shift(@ARRAY): Scalar",
+      "documentation": { "value": "Removes and returns the first element of an array, shifting all other elements down by one." },
+      "parameters": [
+        { "label": "@ARRAY", "documentation": { "value": "The array to shift from. Defaults to @ARGV outside subroutines, @_ inside." } }
+      ]
+    },
+    {
+      "label": "unshift(@ARRAY, LIST): Integer",
+      "documentation": { "value": "Prepends one or more values to the beginning of an array. Returns the new number of elements." },
+      "parameters": [
+        { "label": "@ARRAY", "documentation": { "value": "The array to prepend to." } },
+        { "label": "LIST", "documentation": { "value": "The values to add to the beginning of the array." } }
+      ]
+    },
+    {
+      "label": "length(EXPR): Integer",
+      "documentation": { "value": "Returns the length in characters of the value of EXPR." },
+      "parameters": [
+        { "label": "EXPR", "documentation": { "value": "The string expression. Defaults to $_ if omitted." } }
+      ]
+    },
+    {
+      "label": "substr(EXPR, OFFSET, LENGTH, REPLACEMENT): String",
+      "documentation": { "value": "Extracts a substring from a string. Can optionally replace the extracted portion." },
+      "parameters": [
+        { "label": "EXPR", "documentation": { "value": "The source string." } },
+        { "label": "OFFSET", "documentation": { "value": "The 0-based starting position. Negative values count from the end." } },
+        { "label": "LENGTH", "documentation": { "value": "Optional. The number of characters. Negative values leave that many characters at the end." } },
+        { "label": "REPLACEMENT", "documentation": { "value": "Optional. A string to replace the extracted portion with." } }
+      ]
+    },
+    {
+      "label": "index(STRING, SUBSTR, POSITION): Integer",
+      "documentation": { "value": "Returns the position of the first occurrence of SUBSTR in STRING. Returns -1 if not found." },
+      "parameters": [
+        { "label": "STRING", "documentation": { "value": "The string to search in." } },
+        { "label": "SUBSTR", "documentation": { "value": "The substring to search for." } },
+        { "label": "POSITION", "documentation": { "value": "Optional. The position to start searching from (0-based)." } }
+      ]
+    },
+    {
+      "label": "open(FILEHANDLE, MODE, FILENAME): Boolean",
+      "documentation": { "value": "Opens a file and associates it with a filehandle. Returns true on success." },
+      "parameters": [
+        { "label": "FILEHANDLE", "documentation": { "value": "The filehandle to associate (e.g., my $fh or a bareword)." } },
+        { "label": "MODE", "documentation": { "value": "The open mode: '<' (read), '>' (write), '>>' (append), '+<' (read/write)." } },
+        { "label": "FILENAME", "documentation": { "value": "The path to the file to open." } }
+      ]
+    },
+    {
+      "label": "close(FILEHANDLE): Boolean",
+      "documentation": { "value": "Closes an opened filehandle. Returns true on success." },
+      "parameters": [
+        { "label": "FILEHANDLE", "documentation": { "value": "The filehandle to close." } }
+      ]
+    },
+    {
+      "label": "die(LIST): void",
+      "documentation": { "value": "Raises an exception. Outside an eval, prints the message to STDERR and exits with the current $! value." },
+      "parameters": [
+        { "label": "LIST", "documentation": { "value": "The error message or object to die with. If it doesn't end in a newline, file and line are appended." } }
+      ]
+    },
+    {
+      "label": "warn(LIST): Boolean",
+      "documentation": { "value": "Prints a warning message to STDERR but does not exit the program." },
+      "parameters": [
+        { "label": "LIST", "documentation": { "value": "The warning message. If it doesn't end in a newline, file and line number are appended." } }
+      ]
+    },
+    {
+      "label": "sprintf(FORMAT, LIST): String",
+      "documentation": { "value": "Returns a formatted string (like printf but returns the string instead of printing it)." },
+      "parameters": [
+        { "label": "FORMAT", "documentation": { "value": "The format string with printf-style specifiers (%s, %d, %f, %x, etc.)." } },
+        { "label": "LIST", "documentation": { "value": "The values to substitute into the format string." } }
+      ]
+    }
+  ]
+}

package/data/signatureHelp/pgsql.json

@@ -0,0 +1,126 @@
+{
+  "language": "pgsql",
+  "triggerCharacters": ["(", ","],
+  "retriggerCharacters": [","],
+  "signatures": [
+    {
+      "label": "SELECT column1, column2 FROM table_name WHERE condition",
+      "documentation": { "value": "Retrieves rows from one or more tables. The most commonly used SQL command in PostgreSQL." },
+      "parameters": [
+        { "label": "column1, column2", "documentation": { "value": "The columns to retrieve. Use * for all columns." } },
+        { "label": "table_name", "documentation": { "value": "The table or view to query from." } },
+        { "label": "condition", "documentation": { "value": "Optional WHERE clause to filter results." } }
+      ]
+    },
+    {
+      "label": "INSERT INTO table_name (column1, column2) VALUES (value1, value2) RETURNING *",
+      "documentation": { "value": "Inserts new rows into a table. PostgreSQL supports RETURNING clause to return inserted rows." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The target table." } },
+        { "label": "column1, column2", "documentation": { "value": "The columns to insert values into." } },
+        { "label": "value1, value2", "documentation": { "value": "The values to insert." } }
+      ]
+    },
+    {
+      "label": "UPDATE table_name SET column1 = value1 WHERE condition RETURNING *",
+      "documentation": { "value": "Modifies existing rows in a table. Supports RETURNING to return the updated rows." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The table to update." } },
+        { "label": "column1 = value1", "documentation": { "value": "The column-value assignments." } },
+        { "label": "condition", "documentation": { "value": "The WHERE clause to identify rows to update." } }
+      ]
+    },
+    {
+      "label": "CREATE TABLE table_name (column1 type, column2 type, ...)",
+      "documentation": { "value": "Creates a new table in the database. Supports PostgreSQL-specific types like SERIAL, JSONB, UUID, ARRAY." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The name of the new table (optionally schema-qualified)." } },
+        { "label": "column1 type", "documentation": { "value": "Column definitions with name and type (e.g., id SERIAL PRIMARY KEY, data JSONB)." } }
+      ]
+    },
+    {
+      "label": "ALTER TABLE table_name ADD COLUMN column_name type",
+      "documentation": { "value": "Modifies an existing table definition. Supports ADD/DROP COLUMN, RENAME, SET DEFAULT, constraints." },
+      "parameters": [
+        { "label": "table_name", "documentation": { "value": "The table to alter." } },
+        { "label": "column_name", "documentation": { "value": "The name of the column to add." } },
+        { "label": "type", "documentation": { "value": "The PostgreSQL data type for the new column." } }
+      ]
+    },
+    {
+      "label": "COALESCE(value1, value2, ...): any",
+      "documentation": { "value": "Returns the first non-NULL argument. Often used to provide default values for nullable columns." },
+      "parameters": [
+        { "label": "value1", "documentation": { "value": "The first expression to evaluate." } },
+        { "label": "value2", "documentation": { "value": "The fallback expression if value1 is NULL." } }
+      ]
+    },
+    {
+      "label": "NULLIF(value1, value2): any",
+      "documentation": { "value": "Returns NULL if value1 equals value2; otherwise returns value1. Useful to avoid division-by-zero." },
+      "parameters": [
+        { "label": "value1", "documentation": { "value": "The value to return if not equal to value2." } },
+        { "label": "value2", "documentation": { "value": "The value to compare against." } }
+      ]
+    },
+    {
+      "label": "array_agg(expression ORDER BY ...): anyarray",
+      "documentation": { "value": "Aggregate function that collects all input values into an array." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The expression to aggregate into an array." } }
+      ]
+    },
+    {
+      "label": "string_agg(expression, delimiter ORDER BY ...): text",
+      "documentation": { "value": "Concatenates input values into a string separated by a delimiter." },
+      "parameters": [
+        { "label": "expression", "documentation": { "value": "The text expression to aggregate." } },
+        { "label": "delimiter", "documentation": { "value": "The separator string placed between values." } }
+      ]
+    },
+    {
+      "label": "json_build_object(key1, value1, key2, value2, ...): json",
+      "documentation": { "value": "Builds a JSON object from a variadic argument list of alternating keys and values." },
+      "parameters": [
+        { "label": "key1", "documentation": { "value": "The key for the first entry (must be text)." } },
+        { "label": "value1", "documentation": { "value": "The value for the first entry (any SQL type)." } },
+        { "label": "key2", "documentation": { "value": "The key for the second entry." } },
+        { "label": "value2", "documentation": { "value": "The value for the second entry." } }
+      ]
+    },
+    {
+      "label": "to_char(value, format): text",
+      "documentation": { "value": "Converts a timestamp, interval, integer, or numeric value to a string using a format pattern." },
+      "parameters": [
+        { "label": "value", "documentation": { "value": "The value to format (timestamp, interval, numeric)." } },
+        { "label": "format", "documentation": { "value": "The format pattern (e.g., 'YYYY-MM-DD HH24:MI:SS', 'FM999,999.00')." } }
+      ]
+    },
+    {
+      "label": "date_trunc(field, source): timestamp",
+      "documentation": { "value": "Truncates a timestamp or interval to the specified precision." },
+      "parameters": [
+        { "label": "field", "documentation": { "value": "The precision: 'microseconds', 'milliseconds', 'second', 'minute', 'hour', 'day', 'week', 'month', 'quarter', 'year'." } },
+        { "label": "source", "documentation": { "value": "The timestamp or interval value to truncate." } }
+      ]
+    },
+    {
+      "label": "generate_series(start, stop, step): setof",
+      "documentation": { "value": "Generates a series of values from start to stop with an optional step. Works with integer, bigint, and timestamp types." },
+      "parameters": [
+        { "label": "start", "documentation": { "value": "The start value of the series." } },
+        { "label": "stop", "documentation": { "value": "The end value of the series (inclusive)." } },
+        { "label": "step", "documentation": { "value": "Optional step increment. Defaults to 1 for integers or '1 day' for timestamps." } }
+      ]
+    },
+    {
+      "label": "regexp_matches(string, pattern, flags): text[]",
+      "documentation": { "value": "Returns all captured substrings from a POSIX regular expression match." },
+      "parameters": [
+        { "label": "string", "documentation": { "value": "The string to match against." } },
+        { "label": "pattern", "documentation": { "value": "The POSIX regular expression pattern." } },
+        { "label": "flags", "documentation": { "value": "Optional flags: 'g' (global), 'i' (case-insensitive), 'n' (newline-sensitive)." } }
+      ]
+    }
+  ]
+}