@enjoys/context-engine 1.1.1 → 1.2.0

package/data/definition/powerquery.json

@@ -0,0 +1,101 @@
+{
+  "language": "powerquery",
+  "definitions": {
+    "Table.FromRecords": {
+      "signature": "Table.FromRecords(records as list, optional columns as any, optional missingField as MissingField.Type) -> table",
+      "description": "Converts a list of record values into a table where each record becomes a row and record fields become columns. Handles missing fields according to the specified MissingField strategy.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.SelectRows": {
+      "signature": "Table.SelectRows(table as table, condition as function) -> table",
+      "description": "Returns a table containing only the rows from the input table where the condition function evaluates to true, providing predicate-based row filtering for data transformation pipelines.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.AddColumn": {
+      "signature": "Table.AddColumn(table as table, newColumnName as text, columnGenerator as function, optional columnType as type) -> table",
+      "description": "Adds a new column to the table with values computed by applying the generator function to each row, supporting derived columns and calculated fields in transformation steps.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.TransformColumns": {
+      "signature": "Table.TransformColumns(table as table, transformOperations as list, optional defaultTransformation, optional missingField) -> table",
+      "description": "Applies transformation functions to the specified columns of a table, enabling type conversions, formatting changes, and value modifications across entire columns of data.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.Group": {
+      "signature": "Table.Group(table as table, key as any, aggregatedColumns as list, optional groupKind, optional comparer) -> table",
+      "description": "Groups rows by the specified key columns and applies aggregate operations such as sum, count, and list to the remaining columns, equivalent to SQL GROUP BY functionality.",
+      "type": "function",
+      "module": "Table"
+    },
+    "Table.Join": {
+      "signature": "Table.Join(table1 as table, key1 as any, table2 as table, key2 as any, optional joinKind as JoinKind.Type, optional joinAlgorithm, optional keyEqualityComparers) -> table",
+      "description": "Combines rows from two tables based on matching key values, supporting inner, left outer, right outer, full outer, left anti, and right anti join operations.",
+      "type": "function",
+      "module": "Table"
+    },
+    "List.Transform": {
+      "signature": "List.Transform(list as list, transform as function) -> list",
+      "description": "Applies a transformation function to each element of the input list and returns a new list containing the transformed values, enabling functional mapping operations on collections.",
+      "type": "function",
+      "module": "List"
+    },
+    "List.Select": {
+      "signature": "List.Select(list as list, selection as function) -> list",
+      "description": "Returns a new list containing only the elements from the input list where the selection function returns true, providing predicate-based filtering for list values.",
+      "type": "function",
+      "module": "List"
+    },
+    "List.Accumulate": {
+      "signature": "List.Accumulate(list as list, seed as any, accumulator as function) -> any",
+      "description": "Reduces a list to a single value by applying an accumulator function that takes the current state and each element, producing a running aggregation similar to fold or reduce.",
+      "type": "function",
+      "module": "List"
+    },
+    "Record.Field": {
+      "signature": "Record.Field(record as record, field as text) -> any",
+      "description": "Returns the value of the specified field from the given record. Raises an error if the field does not exist, unlike the optional Record.FieldOrDefault which handles missing fields.",
+      "type": "function",
+      "module": "Record"
+    },
+    "Record.TransformFields": {
+      "signature": "Record.TransformFields(record as record, transformOperations as list, optional missingField) -> record",
+      "description": "Returns a new record with the specified fields transformed by applying the provided functions, enabling selective modification of record field values during data cleaning.",
+      "type": "function",
+      "module": "Record"
+    },
+    "Text.Contains": {
+      "signature": "Text.Contains(text as nullable text, substring as text, optional comparer as function) -> logical",
+      "description": "Returns true if the text value contains the specified substring. Supports an optional comparer function for case-insensitive or culture-aware string matching operations.",
+      "type": "function",
+      "module": "Text"
+    },
+    "Text.Combine": {
+      "signature": "Text.Combine(texts as list, optional separator as nullable text) -> text",
+      "description": "Concatenates a list of text values into a single string with an optional separator between each element, useful for building delimited strings from list-based data.",
+      "type": "function",
+      "module": "Text"
+    },
+    "Number.From": {
+      "signature": "Number.From(value as any, optional culture as nullable text) -> nullable number",
+      "description": "Converts a text, logical, date, time, or other value to a number using the specified culture for locale-aware parsing of decimal separators and number formatting conventions.",
+      "type": "function",
+      "module": "Number"
+    },
+    "Type.Is": {
+      "signature": "Type.Is(type1 as type, type2 as type) -> logical",
+      "description": "Returns true if type1 is compatible with type2, used for runtime type checking and conditional logic based on the data types of values flowing through query transformations.",
+      "type": "function",
+      "module": "Type"
+    },
+    "each": {
+      "signature": "each expression",
+      "description": "Shorthand syntax in Power Query M for creating a single-parameter function where the underscore represents the parameter. Equivalent to writing (_) => expression for concise lambda definitions.",
+      "type": "function",
+      "module": "Language"
+    }
+  }
+}

package/data/definition/qsharp.json

@@ -0,0 +1,95 @@
+{
+  "language": "qsharp",
+  "definitions": {
+    "Qubit": {
+      "signature": "Qubit",
+      "description": "The fundamental quantum data type in Q# representing a single quantum bit that exists in a superposition of states. Qubits are allocated using the use statement and cannot be directly copied or inspected.",
+      "type": "class",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Result": {
+      "signature": "Result = Zero | One",
+      "description": "A classical discriminated union type in Q# representing the outcome of a quantum measurement, with two possible values Zero and One corresponding to the computational basis states.",
+      "type": "class",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "operation": {
+      "signature": "operation Name(params : ParamTypes) : ReturnType { body }",
+      "description": "Declares a Q# operation that can perform quantum side effects including qubit allocation, gate application, and measurement. Operations are the primary callable type for quantum algorithms.",
+      "type": "function",
+      "module": "Language"
+    },
+    "function": {
+      "signature": "function Name(params : ParamTypes) : ReturnType { body }",
+      "description": "Declares a purely classical Q# function with no quantum side effects. Functions cannot allocate qubits, apply gates, or call operations, enabling safe classical computation and optimization.",
+      "type": "function",
+      "module": "Language"
+    },
+    "H": {
+      "signature": "operation H(qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Hadamard gate to a single qubit, transforming the basis state |0> into an equal superposition of |0> and |1>. Essential for creating quantum superpositions and interference patterns.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "CNOT": {
+      "signature": "operation CNOT(control : Qubit, target : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Controlled-NOT gate that flips the target qubit if and only if the control qubit is in state |1>. The fundamental two-qubit gate for creating entanglement in quantum circuits.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "M": {
+      "signature": "operation M(qubit : Qubit) : Result",
+      "description": "Performs a single-qubit measurement in the computational (Z) basis, collapsing the qubit superposition to either Zero or One and returning the classical Result value.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "X": {
+      "signature": "operation X(qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Pauli-X gate (quantum NOT) to a single qubit, flipping |0> to |1> and |1> to |0>. Equivalent to a classical bit flip operation on the quantum state.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Z": {
+      "signature": "operation Z(qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Pauli-Z gate to a single qubit, adding a phase of -1 to the |1> component while leaving |0> unchanged. Used for phase kickback and quantum error correction.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Y": {
+      "signature": "operation Y(qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies the Pauli-Y gate to a single qubit, combining X and Z operations with an imaginary phase factor. Rotates the quantum state around the Y-axis of the Bloch sphere.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Rx": {
+      "signature": "operation Rx(theta : Double, qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies a rotation around the X-axis of the Bloch sphere by the specified angle theta in radians. Used for parameterized quantum circuits and variational quantum algorithms.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "Rz": {
+      "signature": "operation Rz(theta : Double, qubit : Qubit) : Unit is Adj + Ctl",
+      "description": "Applies a rotation around the Z-axis of the Bloch sphere by the specified angle theta in radians. Commonly used for phase manipulation in quantum Fourier transforms.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Intrinsic"
+    },
+    "use": {
+      "signature": "use qubit = Qubit() { ... }",
+      "description": "Allocates one or more fresh qubits initialized in the |0> state for use within the block scope. Qubits must be returned to |0> state before deallocation at scope exit.",
+      "type": "function",
+      "module": "Language"
+    },
+    "MeasureAllZ": {
+      "signature": "operation MeasureAllZ(qubits : Qubit[]) : Result",
+      "description": "Measures all qubits in the given array jointly in the Z-basis and returns a single Result, collapsing the joint quantum state to a computational basis state.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Measurement"
+    },
+    "ApplyToEach": {
+      "signature": "operation ApplyToEach<'T>(singleElementOperation : ('T => Unit), register : 'T[]) : Unit",
+      "description": "Applies a single-qubit operation to every element in a qubit register array. A convenience operation for broadcasting gates across multiple qubits uniformly.",
+      "type": "function",
+      "module": "Microsoft.Quantum.Canon"
+    }
+  }
+}

package/data/definition/r.json

@@ -0,0 +1,84 @@
+{
+  "language": "r",
+  "definitions": {
+    "data.frame": {
+      "signature": "data.frame(..., row.names = NULL, check.rows = FALSE, check.names = TRUE, stringsAsFactors = FALSE)",
+      "description": "A data frame is a table-like structure: a list of equal-length vectors. The fundamental data structure for tabular data in R.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "nrow": { "signature": "nrow(x) -> integer", "description": "Return the number of rows.", "type": "method" },
+        "ncol": { "signature": "ncol(x) -> integer", "description": "Return the number of columns.", "type": "method" },
+        "names": { "signature": "names(x) -> character", "description": "Get column names.", "type": "method" },
+        "colnames": { "signature": "colnames(x) -> character", "description": "Get or set column names.", "type": "method" },
+        "rownames": { "signature": "rownames(x) -> character", "description": "Get or set row names.", "type": "method" },
+        "str": { "signature": "str(x)", "description": "Compactly display structure.", "type": "method" },
+        "summary": { "signature": "summary(x)", "description": "Produce summary statistics.", "type": "method" },
+        "head": { "signature": "head(x, n = 6)", "description": "Return first n rows.", "type": "method" },
+        "tail": { "signature": "tail(x, n = 6)", "description": "Return last n rows.", "type": "method" },
+        "merge": { "signature": "merge(x, y, by, ...)", "description": "Merge two data frames by common columns.", "type": "method" },
+        "subset": { "signature": "subset(x, subset, select)", "description": "Return subsets matching conditions.", "type": "method" },
+        "transform": { "signature": "transform(x, ...)", "description": "Modify or add columns.", "type": "method" },
+        "rbind": { "signature": "rbind(x, ...)", "description": "Combine by rows.", "type": "method" },
+        "cbind": { "signature": "cbind(x, ...)", "description": "Combine by columns.", "type": "method" }
+      }
+    },
+    "list": {
+      "signature": "list(...)",
+      "description": "A generic container that can hold objects of any type, including other lists. Accessed with `[[`, `$`, or `[`.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "length": { "signature": "length(x) -> integer", "description": "Number of elements.", "type": "method" },
+        "names": { "signature": "names(x) -> character|NULL", "description": "Get or set names.", "type": "method" },
+        "append": { "signature": "append(x, values, after)", "description": "Append elements to a list.", "type": "method" },
+        "unlist": { "signature": "unlist(x, recursive = TRUE)", "description": "Flatten a list to a vector.", "type": "method" }
+      }
+    },
+    "matrix": {
+      "signature": "matrix(data = NA, nrow = 1, ncol = 1, byrow = FALSE, dimnames = NULL)",
+      "description": "A two-dimensional array of elements of the same type. Special case of array with 2 dimensions.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "nrow": { "signature": "nrow(x) -> integer", "description": "Number of rows.", "type": "method" },
+        "ncol": { "signature": "ncol(x) -> integer", "description": "Number of columns.", "type": "method" },
+        "dim": { "signature": "dim(x) -> integer(2)", "description": "Dimensions (nrow, ncol).", "type": "method" },
+        "t": { "signature": "t(x) -> matrix", "description": "Transpose the matrix.", "type": "method" },
+        "det": { "signature": "det(x) -> numeric", "description": "Compute the determinant.", "type": "method" },
+        "solve": { "signature": "solve(a, b) -> matrix", "description": "Solve a system of equations or compute inverse.", "type": "method" },
+        "crossprod": { "signature": "crossprod(x, y) -> matrix", "description": "Crossproduct: t(x) %*% y.", "type": "method" },
+        "rowSums": { "signature": "rowSums(x) -> numeric", "description": "Sum of each row.", "type": "method" },
+        "colSums": { "signature": "colSums(x) -> numeric", "description": "Sum of each column.", "type": "method" },
+        "rowMeans": { "signature": "rowMeans(x) -> numeric", "description": "Mean of each row.", "type": "method" },
+        "colMeans": { "signature": "colMeans(x) -> numeric", "description": "Mean of each column.", "type": "method" }
+      }
+    },
+    "factor": {
+      "signature": "factor(x, levels, labels = levels, exclude = NA, ordered = FALSE)",
+      "description": "Categorical variable with a fixed set of possible values (levels). Used extensively in statistical modeling.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "levels": { "signature": "levels(x) -> character", "description": "Get or set the levels.", "type": "method" },
+        "nlevels": { "signature": "nlevels(x) -> integer", "description": "Number of levels.", "type": "method" },
+        "droplevels": { "signature": "droplevels(x)", "description": "Drop unused levels.", "type": "method" },
+        "relevel": { "signature": "relevel(x, ref)", "description": "Reorder levels with ref first.", "type": "method" },
+        "table": { "signature": "table(x) -> table", "description": "Frequency table of levels.", "type": "method" }
+      }
+    },
+    "environment": {
+      "signature": "new.env(hash = TRUE, parent = parent.frame(), size = 29L)",
+      "description": "A frame for variable bindings. Every function has an associated environment. Environments form a tree via parent links.",
+      "type": "class",
+      "module": "base",
+      "members": {
+        "ls": { "signature": "ls(envir = env) -> character", "description": "List objects in environment.", "type": "method" },
+        "get": { "signature": "get(name, envir = env)", "description": "Get a value from the environment.", "type": "method" },
+        "assign": { "signature": "assign(name, value, envir = env)", "description": "Assign a value in the environment.", "type": "method" },
+        "parent.env": { "signature": "parent.env(env) -> environment", "description": "Get parent environment.", "type": "method" },
+        "environmentName": { "signature": "environmentName(env) -> character", "description": "Get environment name.", "type": "method" }
+      }
+    }
+  }
+}

package/data/definition/razor.json

@@ -0,0 +1,108 @@
+{
+  "language": "razor",
+  "definitions": {
+    "@model": {
+      "signature": "@model TypeName",
+      "description": "Declares the strongly-typed model class for a Razor view, enabling IntelliSense and compile-time checking for model property access throughout the view template with @Model references.",
+      "type": "function",
+      "module": "Razor Directives"
+    },
+    "@inject": {
+      "signature": "@inject ServiceType PropertyName",
+      "description": "Injects a registered dependency injection service into the Razor view as a property, making application services like configuration, localization, and custom services available in templates.",
+      "type": "function",
+      "module": "Razor Directives"
+    },
+    "@page": {
+      "signature": "@page [\"route-template\"]",
+      "description": "Marks a Razor file as a Razor Page with an optional custom route template, making it directly routable without a controller. The page handles HTTP requests via OnGet and OnPost handler methods.",
+      "type": "function",
+      "module": "Razor Pages"
+    },
+    "Html.Partial": {
+      "signature": "Html.Partial(partialViewName, model) -> IHtmlContent",
+      "description": "Renders a partial view synchronously and returns the HTML content. For better performance, use Html.PartialAsync or the partial tag helper to avoid blocking the request thread.",
+      "type": "function",
+      "module": "HtmlHelper"
+    },
+    "Html.Raw": {
+      "signature": "Html.Raw(htmlString) -> IHtmlContent",
+      "description": "Returns unencoded HTML markup that is not further HTML-encoded by Razor output. Use with trusted content only as it bypasses the default XSS protection provided by automatic HTML encoding.",
+      "type": "function",
+      "module": "HtmlHelper"
+    },
+    "Html.ActionLink": {
+      "signature": "Html.ActionLink(linkText, actionName, controllerName, routeValues, htmlAttributes) -> IHtmlContent",
+      "description": "Generates an HTML anchor element with an href attribute pointing to the specified controller action, automatically resolving routes and encoding parameters for MVC navigation links.",
+      "type": "function",
+      "module": "HtmlHelper"
+    },
+    "ViewBag": {
+      "signature": "ViewBag.PropertyName -> dynamic",
+      "description": "A dynamic property bag for passing data from controllers to views without strong typing. Uses C# dynamic dispatch so properties are resolved at runtime with no compile-time type checking.",
+      "type": "class",
+      "module": "Microsoft.AspNetCore.Mvc"
+    },
+    "ViewData": {
+      "signature": "ViewData[\"key\"] -> object",
+      "description": "A dictionary-based mechanism for passing data from controllers to views using string keys. Values are typed as object and require casting. ViewBag is a dynamic wrapper around ViewData.",
+      "type": "class",
+      "module": "Microsoft.AspNetCore.Mvc",
+      "members": {
+        "Title": {
+          "signature": "ViewData[\"Title\"] -> string",
+          "description": "Conventionally used to set the page title displayed in the layout _Layout.cshtml.",
+          "type": "method"
+        }
+      }
+    },
+    "TempData": {
+      "signature": "TempData[\"key\"] -> object",
+      "description": "A short-lived dictionary for passing data between two consecutive requests, typically used for redirect-based status messages. Data persists through one subsequent request then is automatically deleted.",
+      "type": "class",
+      "module": "Microsoft.AspNetCore.Mvc"
+    },
+    "Url.Action": {
+      "signature": "Url.Action(actionName, controllerName, routeValues) -> string",
+      "description": "Generates a URL string for the specified controller action using the application routing configuration. Returns a properly encoded URL without creating a full anchor element.",
+      "type": "function",
+      "module": "UrlHelper"
+    },
+    "Url.Content": {
+      "signature": "Url.Content(contentPath) -> string",
+      "description": "Converts a virtual application-relative path starting with tilde to an absolute path, resolving the application root for referencing static files like CSS, JavaScript, and images.",
+      "type": "function",
+      "module": "UrlHelper"
+    },
+    "@section": {
+      "signature": "@section SectionName { content }",
+      "description": "Defines a named content section in a Razor view that can be rendered at a specific location in the layout page using RenderSection. Enables placing scripts, styles, or content in layout-defined areas.",
+      "type": "function",
+      "module": "Razor Directives"
+    },
+    "@using": {
+      "signature": "@using Namespace.Name",
+      "description": "Adds a C# using directive to the Razor view, making types from the specified namespace available without fully qualifying their names throughout the template file.",
+      "type": "function",
+      "module": "Razor Directives"
+    },
+    "@code": {
+      "signature": "@code { C# members }",
+      "description": "Defines a code block in Blazor components containing C# member declarations including fields, properties, methods, and event handlers that form the component logic and state.",
+      "type": "function",
+      "module": "Blazor"
+    },
+    "RenderSection": {
+      "signature": "RenderSection(name, required) -> IHtmlContent",
+      "description": "Renders the content of a named section defined in a child view within the layout page. The required parameter controls whether views must define the section or can omit it.",
+      "type": "function",
+      "module": "Layout"
+    },
+    "RenderBody": {
+      "signature": "RenderBody() -> IHtmlContent",
+      "description": "Renders the main content of a child view within the layout page at the location where RenderBody is called. Every layout page must include exactly one call to RenderBody.",
+      "type": "function",
+      "module": "Layout"
+    }
+  }
+}

package/data/definition/redis.json

@@ -0,0 +1,125 @@
+{
+  "language": "redis",
+  "definitions": {
+    "redis.call": {
+      "signature": "redis.call(command, arg1, arg2, ...) -> reply",
+      "description": "Executes a Redis command from within a Lua script and returns the result. If the command returns an error, redis.call raises a Lua error that aborts the script execution immediately.",
+      "type": "function",
+      "module": "Scripting"
+    },
+    "redis.pcall": {
+      "signature": "redis.pcall(command, arg1, arg2, ...) -> reply",
+      "description": "Executes a Redis command from within a Lua script in protected mode. Unlike redis.call, errors are caught and returned as Lua tables with an err field instead of aborting the script.",
+      "type": "function",
+      "module": "Scripting"
+    },
+    "redis.log": {
+      "signature": "redis.log(loglevel, message)",
+      "description": "Writes a log message to the Redis server log from within a Lua script. Log levels include redis.LOG_DEBUG, redis.LOG_VERBOSE, redis.LOG_NOTICE, and redis.LOG_WARNING.",
+      "type": "function",
+      "module": "Scripting"
+    },
+    "redis.error_reply": {
+      "signature": "redis.error_reply(error_string) -> table",
+      "description": "Creates an error reply table that can be returned from a Lua script to the Redis client, formatted as a Redis error response with the specified error message string.",
+      "type": "function",
+      "module": "Scripting"
+    },
+    "redis.status_reply": {
+      "signature": "redis.status_reply(status_string) -> table",
+      "description": "Creates a status reply table that can be returned from a Lua script to the Redis client, formatted as a Redis simple status response like OK or QUEUED.",
+      "type": "function",
+      "module": "Scripting"
+    },
+    "KEYS": {
+      "signature": "KEYS pattern -> Array<string>",
+      "description": "Returns all keys matching the specified glob-style pattern. Supports wildcards: * matches any sequence, ? matches one character, and [ae] matches character classes. Avoid in production due to O(N) scan.",
+      "type": "function",
+      "module": "Generic"
+    },
+    "TYPE": {
+      "signature": "TYPE key -> string",
+      "description": "Returns the data type of the value stored at the given key as a string: string, list, set, zset, hash, stream, or none if the key does not exist in the database.",
+      "type": "function",
+      "module": "Generic"
+    },
+    "TTL": {
+      "signature": "TTL key -> integer",
+      "description": "Returns the remaining time to live of a key that has a timeout set, in whole seconds. Returns -1 if the key exists but has no expiry, or -2 if the key does not exist.",
+      "type": "function",
+      "module": "Generic"
+    },
+    "PTTL": {
+      "signature": "PTTL key -> integer",
+      "description": "Returns the remaining time to live of a key in milliseconds for higher precision than TTL. Returns -1 for keys without expiry and -2 for non-existent keys.",
+      "type": "function",
+      "module": "Generic"
+    },
+    "EXPIRE": {
+      "signature": "EXPIRE key seconds [NX|XX|GT|LT] -> integer",
+      "description": "Sets a timeout on a key in seconds after which it will be automatically deleted. Returns 1 if set successfully, 0 if key does not exist. Supports NX, XX, GT, LT flags in Redis 7.0+.",
+      "type": "function",
+      "module": "Generic"
+    },
+    "PERSIST": {
+      "signature": "PERSIST key -> integer",
+      "description": "Removes the existing timeout on a key, making it persistent so it will not be automatically deleted. Returns 1 if the timeout was removed, 0 if the key has no associated timeout.",
+      "type": "function",
+      "module": "Generic"
+    },
+    "SCAN": {
+      "signature": "SCAN cursor [MATCH pattern] [COUNT count] [TYPE type] -> [cursor, Array<string>]",
+      "description": "Incrementally iterates over the key space using a cursor-based approach, returning a new cursor and a batch of keys. Production-safe alternative to KEYS for large databases without blocking.",
+      "type": "function",
+      "module": "Generic"
+    },
+    "EVAL": {
+      "signature": "EVAL script numkeys [key ...] [arg ...] -> reply",
+      "description": "Evaluates a Lua script server-side with atomic execution guarantee. The script receives keys via KEYS table and arguments via ARGV table. All Redis commands within the script are atomic.",
+      "type": "function",
+      "module": "Scripting"
+    },
+    "EVALSHA": {
+      "signature": "EVALSHA sha1 numkeys [key ...] [arg ...] -> reply",
+      "description": "Evaluates a previously loaded Lua script by its SHA1 hash, avoiding retransmission of the script body. Use SCRIPT LOAD to cache the script and obtain its SHA1 digest.",
+      "type": "function",
+      "module": "Scripting"
+    },
+    "SCRIPT LOAD": {
+      "signature": "SCRIPT LOAD script -> string",
+      "description": "Loads a Lua script into the Redis script cache without executing it, returning the SHA1 digest of the script. The cached script can then be executed with EVALSHA for reduced bandwidth.",
+      "type": "function",
+      "module": "Scripting"
+    },
+    "CONFIG GET": {
+      "signature": "CONFIG GET parameter -> Array<string>",
+      "description": "Retrieves the value of a Redis configuration parameter at runtime. Supports glob-style patterns to retrieve multiple parameters at once for server introspection and diagnostics.",
+      "type": "function",
+      "module": "Server"
+    },
+    "CONFIG SET": {
+      "signature": "CONFIG SET parameter value [parameter value ...] -> string",
+      "description": "Dynamically reconfigures a Redis server parameter at runtime without restart. Not all parameters are modifiable; some require a server restart to take effect from the configuration file.",
+      "type": "function",
+      "module": "Server"
+    },
+    "INFO": {
+      "signature": "INFO [section ...] -> string",
+      "description": "Returns detailed information and statistics about the Redis server in a human-readable format. Sections include server, clients, memory, stats, replication, cpu, keyspace, and modules.",
+      "type": "function",
+      "module": "Server"
+    },
+    "MULTI": {
+      "signature": "MULTI -> string",
+      "description": "Marks the start of a Redis transaction block. Subsequent commands are queued for atomic execution when EXEC is called. All commands in the transaction execute sequentially without interruption.",
+      "type": "function",
+      "module": "Transactions"
+    },
+    "EXEC": {
+      "signature": "EXEC -> Array<reply>",
+      "description": "Executes all previously queued commands in a MULTI transaction block atomically and returns an array of replies, one for each command in the order they were queued.",
+      "type": "function",
+      "module": "Transactions"
+    }
+  }
+}

package/data/definition/redshift.json

@@ -0,0 +1,112 @@
+{
+  "language": "redshift",
+  "definitions": {
+    "COPY": {
+      "signature": "COPY table_name FROM 's3://bucket/path' IAM_ROLE 'arn:aws:iam::role' [FORMAT AS CSV|JSON|AVRO|PARQUET] [DELIMITER 'char'] [IGNOREHEADER n] [GZIP|LZOP|BZIP2]",
+      "description": "Loads data from Amazon S3, DynamoDB, or remote hosts into a Redshift table using massively parallel processing for high-throughput bulk ingestion of large datasets.",
+      "type": "statement",
+      "module": "Data Loading"
+    },
+    "UNLOAD": {
+      "signature": "UNLOAD ('select_statement') TO 's3://bucket/path' IAM_ROLE 'arn:aws:iam::role' [FORMAT AS CSV|JSON|PARQUET] [PARALLEL ON|OFF] [MAXFILESIZE n MB]",
+      "description": "Exports the results of a query to one or more files on Amazon S3, supporting parallel writes across slices for fast extraction of large result sets.",
+      "type": "statement",
+      "module": "Data Unloading"
+    },
+    "GETDATE": {
+      "signature": "GETDATE() -> TIMESTAMP",
+      "description": "Returns the current date and time in UTC as a timestamp value, equivalent to CURRENT_TIMESTAMP but specific to Redshift SQL dialect for compatibility purposes.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "DATEADD": {
+      "signature": "DATEADD(datepart, interval, expression) -> TIMESTAMP|DATE",
+      "description": "Adds a specified number of intervals (years, months, days, hours, minutes, seconds) to a date or timestamp expression and returns the resulting value.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "DATEDIFF": {
+      "signature": "DATEDIFF(datepart, start_date, end_date) -> BIGINT",
+      "description": "Calculates the difference between two date or timestamp expressions in the specified date part units such as years, months, days, hours, minutes, or seconds.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "NVL": {
+      "signature": "NVL(expression1, expression2) -> value",
+      "description": "Returns the first non-null expression among its arguments, functioning as a null-coalescing operator equivalent to COALESCE with exactly two parameters in standard SQL.",
+      "type": "function",
+      "module": "Conditional Functions"
+    },
+    "LISTAGG": {
+      "signature": "LISTAGG(expression [, delimiter]) WITHIN GROUP (ORDER BY sort_expression) -> VARCHAR",
+      "description": "Aggregates values from multiple rows into a single concatenated string with an optional delimiter, ordered by the specified sort expression within each group.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "DISTKEY": {
+      "signature": "DISTKEY (column_name)",
+      "description": "Table distribution style attribute that specifies the column used to distribute rows across compute node slices, optimizing join performance by co-locating matching rows on the same node.",
+      "type": "keyword",
+      "module": "Table Design"
+    },
+    "SORTKEY": {
+      "signature": "SORTKEY (column_name [, ...]) | COMPOUND SORTKEY (...) | INTERLEAVED SORTKEY (...)",
+      "description": "Defines the sort order of data stored on disk within each slice, enabling zone map filtering to skip blocks during query execution and dramatically reducing I/O for filtered queries.",
+      "type": "keyword",
+      "module": "Table Design"
+    },
+    "DISTSTYLE": {
+      "signature": "DISTSTYLE EVEN | KEY | ALL | AUTO",
+      "description": "Specifies how table rows are distributed across compute node slices; EVEN distributes round-robin, KEY uses a column hash, ALL replicates to every node, and AUTO lets Redshift choose.",
+      "type": "keyword",
+      "module": "Table Design"
+    },
+    "APPROXIMATE COUNT": {
+      "signature": "APPROXIMATE COUNT(DISTINCT column) -> BIGINT",
+      "description": "Returns an approximate distinct count using a HyperLogLog algorithm, providing significantly faster results than exact COUNT DISTINCT for large datasets with minimal error margin.",
+      "type": "function",
+      "module": "Aggregate Functions"
+    },
+    "CONVERT_TIMEZONE": {
+      "signature": "CONVERT_TIMEZONE('source_timezone', 'target_timezone', timestamp) -> TIMESTAMP",
+      "description": "Converts a timestamp from one time zone to another, supporting IANA time zone names and UTC offsets for accurate cross-timezone date and time calculations in analytics.",
+      "type": "function",
+      "module": "Date/Time Functions"
+    },
+    "WLM_QUERY_SLOT_COUNT": {
+      "signature": "SET WLM_QUERY_SLOT_COUNT TO n",
+      "description": "Temporarily increases the number of workload management query slots allocated to the current session, allowing a single query to use more memory for complex operations.",
+      "type": "statement",
+      "module": "Workload Management"
+    },
+    "STL_QUERY": {
+      "signature": "SELECT * FROM STL_QUERY WHERE ...",
+      "description": "System table that logs information about database queries including query text, start and end times, and status, essential for monitoring and troubleshooting query performance.",
+      "type": "class",
+      "module": "System Tables",
+      "members": {
+        "query": {
+          "signature": "STL_QUERY.query -> INTEGER",
+          "description": "Unique query identifier assigned by Redshift.",
+          "type": "method"
+        },
+        "querytxt": {
+          "signature": "STL_QUERY.querytxt -> VARCHAR",
+          "description": "Text of the SQL query truncated to 4000 characters.",
+          "type": "method"
+        },
+        "elapsed": {
+          "signature": "STL_QUERY.elapsed -> BIGINT",
+          "description": "Elapsed execution time in microseconds.",
+          "type": "method"
+        }
+      }
+    },
+    "SPECTRUM": {
+      "signature": "CREATE EXTERNAL SCHEMA schema_name FROM DATA CATALOG DATABASE 'db' IAM_ROLE 'arn' CREATE EXTERNAL DATABASE IF NOT EXISTS",
+      "description": "Redshift Spectrum enables querying data stored in Amazon S3 using external tables without loading, leveraging the Glue Data Catalog for schema definitions and partition management.",
+      "type": "statement",
+      "module": "External Tables"
+    }
+  }
+}