@enjoys/context-engine 1.1.1 → 1.1.2

package/data/defination/doctest.json

@@ -0,0 +1,106 @@
+{
+  "language": "doctest",
+  "definitions": {
+    "testmod": {
+      "signature": "doctest.testmod(m=None, name=None, globs=None, verbose=None, report=True, optionflags=0, extraglobs=None, raise_on_error=False) -> TestResults",
+      "description": "Tests the interactive examples in the docstrings of all functions, classes, and the module itself within the given module (or __main__ by default). This is the primary entry point for running doctests in a module and returns a TestResults namedtuple with (failed, attempted) counts.",
+      "type": "function",
+      "module": "doctest"
+    },
+    "testfile": {
+      "signature": "doctest.testfile(filename, module_relative=True, name=None, package=None, globs=None, verbose=None, report=True, optionflags=0, extraglobs=None, raise_on_error=False, parser=DocTestParser(), encoding=None) -> TestResults",
+      "description": "Tests the interactive examples in a text file containing doctest-formatted examples. The file is read and its examples are executed in a clean namespace. Returns a TestResults namedtuple indicating how many tests were attempted and how many failed.",
+      "type": "function",
+      "module": "doctest"
+    },
+    "run_docstring_examples": {
+      "signature": "doctest.run_docstring_examples(f, globs, verbose=False, name='NoName', compileflags=None, optionflags=0) -> None",
+      "description": "Tests the interactive examples associated with a single object's docstring. Useful for running doctests on a specific function or class without testing the entire module. The globs argument provides the namespace for evaluating the examples.",
+      "type": "function",
+      "module": "doctest"
+    },
+    "DocTestParser": {
+      "signature": "class doctest.DocTestParser",
+      "description": "Parses a string (typically a docstring) into a DocTest object containing a list of Example objects. The parser identifies interactive Python examples by looking for '>>>' prompts and groups them with their expected output. Handles continuation lines ('...') and interleaved explanatory text.",
+      "type": "class",
+      "module": "doctest",
+      "members": {
+        "get_doctest": {
+          "signature": "parser.get_doctest(string, globs, name, filename, lineno) -> DocTest",
+          "description": "Parses the given string and returns a DocTest object with the extracted examples, ready for execution.",
+          "type": "method"
+        },
+        "get_examples": {
+          "signature": "parser.get_examples(string, name='<string>') -> list[Example]",
+          "description": "Extracts all Example objects from the string, returning them as a list without creating a full DocTest object.",
+          "type": "method"
+        },
+        "parse": {
+          "signature": "parser.parse(string, name='<string>') -> list[str | Example]",
+          "description": "Divides the string into a list of alternating text chunks and Example objects, preserving all content.",
+          "type": "method"
+        }
+      }
+    },
+    "DocTestRunner": {
+      "signature": "class doctest.DocTestRunner(checker=None, verbose=None, optionflags=0)",
+      "description": "Executes the examples in a DocTest object and reports the results. The runner compares actual output against expected output using an OutputChecker and tracks pass/fail statistics. Supports verbose mode for detailed reporting and custom option flags for controlling comparison behavior.",
+      "type": "class",
+      "module": "doctest",
+      "members": {
+        "run": {
+          "signature": "runner.run(test, compileflags=None, out=None, clear_globs=True) -> TestResults",
+          "description": "Runs the examples in the given DocTest, returning TestResults with (failed, attempted) counts.",
+          "type": "method"
+        },
+        "summarize": {
+          "signature": "runner.summarize(verbose=None) -> TestResults",
+          "description": "Prints a summary of all test cases that have been run by this runner, including pass/fail totals.",
+          "type": "method"
+        },
+        "merge": {
+          "signature": "runner.merge(other) -> None",
+          "description": "Merges the results from another DocTestRunner into this one, combining the test statistics.",
+          "type": "method"
+        }
+      }
+    },
+    "DocTestFinder": {
+      "signature": "class doctest.DocTestFinder(verbose=False, parser=DocTestParser(), recurse=True, exclude_empty=True)",
+      "description": "Finds all docstrings in a module and extracts DocTest objects from them. Recursively explores classes, functions, methods, properties, and nested objects to find all testable docstrings. The exclude_empty option skips objects whose docstrings contain no examples.",
+      "type": "class",
+      "module": "doctest",
+      "members": {
+        "find": {
+          "signature": "finder.find(obj, name=None, globs=None, extraglobs=None) -> list[DocTest]",
+          "description": "Returns a list of DocTest objects found by examining the docstrings of obj and its contained objects recursively.",
+          "type": "method"
+        }
+      }
+    },
+    "Example": {
+      "signature": "class doctest.Example(source, want, exc_msg=None, lineno=0, indent=0, options=None)",
+      "description": "Represents a single interactive Python example consisting of a source code statement (the part after '>>>') and its expected output (the lines following the source before the next '>>>' or blank line). Examples are the atomic unit of doctest testing.",
+      "type": "class",
+      "module": "doctest"
+    },
+    "DocTest": {
+      "signature": "class doctest.DocTest(examples, globs, name, filename, lineno, docstring)",
+      "description": "A collection of related Example objects extracted from a single docstring, along with metadata about where it was found. DocTest objects are created by DocTestParser and executed by DocTestRunner to verify that code examples produce their documented output.",
+      "type": "class",
+      "module": "doctest"
+    },
+    "ELLIPSIS": {
+      "signature": "doctest.ELLIPSIS",
+      "description": "An option flag that allows '...' in expected output to match any substring in the actual output. This is invaluable for writing doctests with output containing memory addresses, timestamps, or other variable content that changes between runs.",
+      "type": "function",
+      "module": "doctest"
+    },
+    "NORMALIZE_WHITESPACE": {
+      "signature": "doctest.NORMALIZE_WHITESPACE",
+      "description": "An option flag that makes all whitespace sequences (spaces, tabs, newlines) compare as equal when checking expected versus actual output. Useful when exact formatting may vary across platforms or Python versions.",
+      "type": "function",
+      "module": "doctest"
+    }
+  }
+}

package/data/defination/ecl.json

@@ -0,0 +1,92 @@
+{
+  "language": "ecl",
+  "definitions": {
+    "RECORD": {
+      "signature": "recname := RECORD fieldtype fieldname; ... END;",
+      "description": "Defines a record structure (schema) that describes the layout of fields in a dataset. Each field has a data type and name. Records are the fundamental building block for defining the shape of data flowing through ECL transformations and are analogous to row schemas in SQL tables.",
+      "type": "keyword",
+      "module": "ECL Language"
+    },
+    "DATASET": {
+      "signature": "dsname := DATASET(filename, recstruct, filetype)",
+      "description": "Declares a dataset, which is the primary data structure in ECL representing a collection of records stored in a logical file on the HPCC cluster. Datasets can be read from disk, created inline, or produced as output from transforms and operations. They are the core data-flow abstraction.",
+      "type": "keyword",
+      "module": "ECL Language",
+      "members": {
+        "SORT": {
+          "signature": "SORT(dataset, field1, field2, ...)",
+          "description": "Returns a new dataset with records sorted by the specified fields in ascending order (prefix with - for descending).",
+          "type": "function"
+        },
+        "FILTER": {
+          "signature": "dataset(condition)",
+          "description": "Filters the dataset to include only records where the Boolean condition evaluates to true.",
+          "type": "function"
+        },
+        "COUNT": {
+          "signature": "COUNT(dataset) -> INTEGER",
+          "description": "Returns the total number of records in the dataset as an integer value.",
+          "type": "function"
+        },
+        "TABLE": {
+          "signature": "TABLE(dataset, record_layout, group_fields)",
+          "description": "Creates a cross-tab (aggregation) of the dataset, grouping by specified fields and computing aggregate expressions.",
+          "type": "function"
+        },
+        "JOIN": {
+          "signature": "JOIN(left, right, condition, transform, jointype)",
+          "description": "Combines records from two datasets based on a matching condition, applying a transform to produce output records.",
+          "type": "function"
+        }
+      }
+    },
+    "OUTPUT": {
+      "signature": "OUTPUT(expression [, recorddef] [, filename] [, options])",
+      "description": "Writes data to the HPCC cluster's distributed file system, displays results in the ECL Watch workunit viewer, or sends data to a specified destination. OUTPUT is the primary way to materialize results from ECL computations and make them available for downstream processes.",
+      "type": "function",
+      "module": "ECL Actions"
+    },
+    "TRANSFORM": {
+      "signature": "recstruct funcname(recstruct L, recstruct R) := TRANSFORM SELF.field := expression; ... END;",
+      "description": "Defines a transformation function that produces a new record from one or more input records. Transforms specify how each output field is computed from input fields using SELF assignments. They are used with PROJECT, JOIN, ROLLUP, and other operations to reshape data.",
+      "type": "keyword",
+      "module": "ECL Language"
+    },
+    "STRING": {
+      "signature": "STRING[n]",
+      "description": "A fixed-length or variable-length character string data type in ECL. STRING without a size specifier is variable-length. STRING[n] declares a fixed-length string of n characters. Strings support concatenation (+), comparison, and pattern matching operations for text processing.",
+      "type": "class",
+      "module": "ECL Types"
+    },
+    "INTEGER": {
+      "signature": "INTEGER[n]",
+      "description": "A signed integer data type in ECL. The optional size specifier [n] indicates the number of bytes (1-8) used for storage, determining the range of values. INTEGER4 is a 4-byte signed integer (-2^31 to 2^31-1). Without a size, defaults to INTEGER8 for maximum range.",
+      "type": "class",
+      "module": "ECL Types"
+    },
+    "REAL": {
+      "signature": "REAL[n]",
+      "description": "A floating-point numeric data type in ECL using IEEE 754 representation. REAL4 provides single-precision (32-bit) and REAL8 provides double-precision (64-bit) floating-point numbers. Used for scientific computations and values requiring decimal precision.",
+      "type": "class",
+      "module": "ECL Types"
+    },
+    "SET": {
+      "signature": "SET OF type",
+      "description": "Declares a set data type containing an ordered collection of values of the same type. Sets in ECL support the IN operator for membership testing and can be created from literals, dataset field values, or function results. Used for filtering and lookup operations.",
+      "type": "class",
+      "module": "ECL Types"
+    },
+    "PROJECT": {
+      "signature": "PROJECT(dataset, transform)",
+      "description": "Applies a transform function to every record in the dataset, producing a new dataset with potentially different field structure. PROJECT is the primary operation for reshaping records, computing derived fields, renaming fields, and changing record schemas one record at a time.",
+      "type": "function",
+      "module": "ECL Operations"
+    },
+    "ROLLUP": {
+      "signature": "ROLLUP(dataset, condition, transform)",
+      "description": "Combines adjacent records that match the specified condition into a single record using the transform function. The dataset must be sorted by the grouping fields first. ROLLUP is used for aggregation, deduplication, and summarization of sorted datasets.",
+      "type": "function",
+      "module": "ECL Operations"
+    }
+  }
+}

package/data/defination/elixir.json

@@ -0,0 +1,244 @@
+{
+  "language": "elixir",
+  "definitions": {
+    "Enum": {
+      "signature": "defmodule Enum",
+      "description": "The Enum module provides a comprehensive set of algorithms for enumerating over collections that implement the Enumerable protocol (lists, maps, ranges, streams). It includes functions for mapping, filtering, reducing, sorting, grouping, and chunking — forming the backbone of data transformation in Elixir.",
+      "type": "module",
+      "module": "Elixir.Enum",
+      "members": {
+        "map": {
+          "signature": "Enum.map(enumerable, fun) :: list",
+          "description": "Returns a list where each element is the result of invoking fun on the corresponding element of the enumerable.",
+          "type": "function"
+        },
+        "filter": {
+          "signature": "Enum.filter(enumerable, fun) :: list",
+          "description": "Returns a list of elements for which the function returns a truthy value.",
+          "type": "function"
+        },
+        "reduce": {
+          "signature": "Enum.reduce(enumerable, acc, fun) :: term",
+          "description": "Invokes fun for each element with the accumulator, reducing the enumerable to a single value.",
+          "type": "function"
+        },
+        "each": {
+          "signature": "Enum.each(enumerable, fun) :: :ok",
+          "description": "Invokes the given function for each element in the enumerable for side effects only, returns :ok.",
+          "type": "function"
+        },
+        "sort": {
+          "signature": "Enum.sort(enumerable, sorter \\\\ :asc) :: list",
+          "description": "Sorts the enumerable according to Erlang's term ordering or a custom comparison function.",
+          "type": "function"
+        },
+        "find": {
+          "signature": "Enum.find(enumerable, default \\\\ nil, fun) :: term",
+          "description": "Returns the first element for which fun returns a truthy value, or default if no such element exists.",
+          "type": "function"
+        },
+        "group_by": {
+          "signature": "Enum.group_by(enumerable, key_fun, value_fun \\\\ fn x -> x end) :: map",
+          "description": "Groups elements by the result of the key function into a map of lists.",
+          "type": "function"
+        },
+        "count": {
+          "signature": "Enum.count(enumerable) :: non_neg_integer",
+          "description": "Returns the number of elements in the enumerable.",
+          "type": "function"
+        }
+      }
+    },
+    "Map": {
+      "signature": "defmodule Map",
+      "description": "The Map module provides functions for creating and manipulating maps, which are key-value stores in Elixir. Maps allow any value as a key, provide O(log n) access, and are the primary data structure for representing structured data. Map literals use the %{key => value} syntax.",
+      "type": "module",
+      "module": "Elixir.Map",
+      "members": {
+        "new": {
+          "signature": "Map.new(enumerable \\\\ []) :: map",
+          "description": "Creates a new map from an enumerable of key-value pairs (2-element tuples).",
+          "type": "function"
+        },
+        "get": {
+          "signature": "Map.get(map, key, default \\\\ nil) :: value",
+          "description": "Returns the value associated with the key, or the default if the key is not present.",
+          "type": "function"
+        },
+        "put": {
+          "signature": "Map.put(map, key, value) :: map",
+          "description": "Returns a new map with the key-value pair added or updated, preserving all other entries.",
+          "type": "function"
+        },
+        "delete": {
+          "signature": "Map.delete(map, key) :: map",
+          "description": "Returns a new map with the given key removed; returns the map unchanged if key is absent.",
+          "type": "function"
+        },
+        "merge": {
+          "signature": "Map.merge(map1, map2, fun \\\\ fn _k, _v1, v2 -> v2 end) :: map",
+          "description": "Merges two maps into one, using the function to resolve conflicts when both maps contain the same key.",
+          "type": "function"
+        },
+        "keys": {
+          "signature": "Map.keys(map) :: list",
+          "description": "Returns a list of all keys in the map.",
+          "type": "function"
+        }
+      }
+    },
+    "List": {
+      "signature": "defmodule List",
+      "description": "The List module provides functions specific to linked lists, which are the fundamental ordered collection in Elixir. Lists support pattern matching with [head | tail] destructuring, are immutable, and prepending is O(1). For general collection operations, use Enum instead.",
+      "type": "module",
+      "module": "Elixir.List",
+      "members": {
+        "first": {
+          "signature": "List.first(list, default \\\\ nil) :: term",
+          "description": "Returns the first element of the list, or default if the list is empty.",
+          "type": "function"
+        },
+        "last": {
+          "signature": "List.last(list, default \\\\ nil) :: term",
+          "description": "Returns the last element of the list, or default if the list is empty.",
+          "type": "function"
+        },
+        "flatten": {
+          "signature": "List.flatten(list) :: list",
+          "description": "Recursively flattens nested lists into a single flat list.",
+          "type": "function"
+        },
+        "zip": {
+          "signature": "List.zip(list_of_lists) :: list",
+          "description": "Zips corresponding elements from multiple lists into a list of tuples.",
+          "type": "function"
+        }
+      }
+    },
+    "String": {
+      "signature": "defmodule String",
+      "description": "The String module provides functions for manipulating UTF-8 encoded binary strings. Elixir strings are binaries and fully support Unicode. The module handles grapheme clusters correctly, distinguishing between bytes, codepoints, and graphemes for accurate text processing.",
+      "type": "module",
+      "module": "Elixir.String",
+      "members": {
+        "split": {
+          "signature": "String.split(string, pattern, opts \\\\ []) :: list(String.t())",
+          "description": "Divides the string into substrings based on the given pattern (string, regex, or list of strings).",
+          "type": "function"
+        },
+        "replace": {
+          "signature": "String.replace(subject, pattern, replacement, opts \\\\ []) :: String.t()",
+          "description": "Returns a new string with occurrences of pattern replaced by replacement.",
+          "type": "function"
+        },
+        "trim": {
+          "signature": "String.trim(string) :: String.t()",
+          "description": "Returns a string with leading and trailing Unicode whitespace removed.",
+          "type": "function"
+        },
+        "contains?": {
+          "signature": "String.contains?(string, contents) :: boolean",
+          "description": "Returns true if the string contains any of the given contents (string or list of strings).",
+          "type": "function"
+        },
+        "length": {
+          "signature": "String.length(string) :: non_neg_integer",
+          "description": "Returns the number of Unicode graphemes in the string (the perceived character count).",
+          "type": "function"
+        }
+      }
+    },
+    "IO": {
+      "signature": "defmodule IO",
+      "description": "The IO module provides functions for handling input and output operations in Elixir. It supports reading from and writing to standard I/O, files, and other I/O devices. IO functions accept iolists (nested lists of integers and binaries) for efficient output without prior concatenation.",
+      "type": "module",
+      "module": "Elixir.IO",
+      "members": {
+        "puts": {
+          "signature": "IO.puts(device \\\\ :stdio, item) :: :ok",
+          "description": "Writes the item to the device followed by a newline character.",
+          "type": "function"
+        },
+        "inspect": {
+          "signature": "IO.inspect(item, opts \\\\ []) :: item",
+          "description": "Inspects and prints the item, then returns it unchanged — perfect for debugging in pipelines.",
+          "type": "function"
+        },
+        "write": {
+          "signature": "IO.write(device \\\\ :stdio, chardata) :: :ok",
+          "description": "Writes the chardata to the device without appending a newline.",
+          "type": "function"
+        }
+      }
+    },
+    "GenServer": {
+      "signature": "defmodule GenServer (behaviour)",
+      "description": "A behaviour module for implementing client-server relationships in OTP. GenServer abstracts the common patterns of a server process that maintains state, handles synchronous (call) and asynchronous (cast) requests, and manages lifecycle callbacks (init, terminate, handle_info).",
+      "type": "module",
+      "module": "Elixir.GenServer",
+      "members": {
+        "start_link": {
+          "signature": "GenServer.start_link(module, init_arg, opts \\\\ []) :: {:ok, pid} | {:error, term}",
+          "description": "Starts a GenServer process linked to the current process, which will be restarted by its supervisor if it crashes.",
+          "type": "function"
+        },
+        "call": {
+          "signature": "GenServer.call(server, request, timeout \\\\ 5000) :: term",
+          "description": "Makes a synchronous request to the server and waits for its reply, with a configurable timeout.",
+          "type": "function"
+        },
+        "cast": {
+          "signature": "GenServer.cast(server, request) :: :ok",
+          "description": "Sends an asynchronous request to the server without waiting for a reply.",
+          "type": "function"
+        }
+      }
+    },
+    "Task": {
+      "signature": "defmodule Task",
+      "description": "The Task module provides conveniences for spawning and awaiting concurrent work in Elixir. Tasks are used for running computations in parallel, especially for fan-out operations where multiple independent pieces of work can execute simultaneously and their results collected later.",
+      "type": "module",
+      "module": "Elixir.Task",
+      "members": {
+        "async": {
+          "signature": "Task.async(fun) :: Task.t()",
+          "description": "Starts a task that can be awaited on, linked to the caller process for error propagation.",
+          "type": "function"
+        },
+        "await": {
+          "signature": "Task.await(task, timeout \\\\ 5000) :: term",
+          "description": "Awaits a task reply and returns the result, raising if the task fails or times out.",
+          "type": "function"
+        },
+        "async_stream": {
+          "signature": "Task.async_stream(enumerable, fun, opts \\\\ []) :: Enumerable.t()",
+          "description": "Returns a stream that runs the given function concurrently on each element of the enumerable with configurable concurrency.",
+          "type": "function"
+        }
+      }
+    },
+    "Stream": {
+      "signature": "defmodule Stream",
+      "description": "The Stream module provides lazy, composable operations on enumerables. Unlike Enum, Stream operations return lazy enumerables that are only computed when consumed. This enables processing large datasets or infinite sequences without loading everything into memory at once.",
+      "type": "module",
+      "module": "Elixir.Stream",
+      "members": {
+        "map": {
+          "signature": "Stream.map(enum, fun) :: Enumerable.t()",
+          "description": "Creates a lazy stream that applies fun to each element when consumed.",
+          "type": "function"
+        },
+        "filter": {
+          "signature": "Stream.filter(enum, fun) :: Enumerable.t()",
+          "description": "Creates a lazy stream that only emits elements for which fun returns a truthy value.",
+          "type": "function"
+        },
+        "chunk_every": {
+          "signature": "Stream.chunk_every(enum, count, step \\\\ count, leftover \\\\ []) :: Enumerable.t()",
+          "description": "Creates a lazy stream that chunks elements into lists of the given count.",
+          "type": "function"
+        }
+      }
+    }
+  }
+}

package/data/defination/flow9.json

@@ -0,0 +1,156 @@
+{
+  "language": "flow9",
+  "definitions": {
+    "array": {
+      "signature": "[T]",
+      "description": "The array type in Flow9 represents an immutable, ordered sequence of elements of the same type. Arrays are the primary collection type and are created using bracket syntax [1, 2, 3]. Since Flow9 arrays are persistent, operations that modify content return new arrays while leaving the original unchanged.",
+      "type": "class",
+      "module": "Flow9 Runtime",
+      "members": {
+        "length": {
+          "signature": "length(a : [?]) -> int",
+          "description": "Returns the number of elements in the array.",
+          "type": "function"
+        },
+        "concat": {
+          "signature": "concat(a : [?], b : [?]) -> [?]",
+          "description": "Returns a new array that is the concatenation of the two input arrays.",
+          "type": "function"
+        },
+        "map": {
+          "signature": "map(a : [?], fn : (?) -> ??) -> [??]",
+          "description": "Returns a new array with the function applied to each element of the input array.",
+          "type": "function"
+        },
+        "filter": {
+          "signature": "filter(a : [?], fn : (?) -> bool) -> [?]",
+          "description": "Returns a new array containing only the elements for which the predicate function returns true.",
+          "type": "function"
+        },
+        "fold": {
+          "signature": "fold(a : [?], init : ??, fn : (??, ?) -> ??) -> ??",
+          "description": "Reduces the array to a single value by applying the function to the accumulator and each element from left to right.",
+          "type": "function"
+        },
+        "arrayPush": {
+          "signature": "arrayPush(a : [?], v : ?) -> [?]",
+          "description": "Returns a new array with the given value appended as the last element.",
+          "type": "function"
+        }
+      }
+    },
+    "tree": {
+      "signature": "Tree<K, V>",
+      "description": "The Tree type in Flow9 is an immutable balanced binary search tree (similar to a sorted map/dictionary) that maps keys to values. Trees provide O(log n) lookup, insertion, and deletion. They are the standard key-value data structure when ordered access or efficient lookup by key is needed.",
+      "type": "class",
+      "module": "Flow9 Runtime",
+      "members": {
+        "makeTree": {
+          "signature": "makeTree() -> Tree<?, ??>",
+          "description": "Creates a new empty tree with no key-value bindings.",
+          "type": "function"
+        },
+        "setTree": {
+          "signature": "setTree(tree : Tree<?, ??>, key : ?, value : ??) -> Tree<?, ??>",
+          "description": "Returns a new tree with the given key-value pair added or updated.",
+          "type": "function"
+        },
+        "lookupTree": {
+          "signature": "lookupTree(tree : Tree<?, ??>, key : ?) -> Maybe<??>",
+          "description": "Looks up a key in the tree, returning Some(value) if found or None() if absent.",
+          "type": "function"
+        },
+        "removeFromTree": {
+          "signature": "removeFromTree(tree : Tree<?, ??>, key : ?) -> Tree<?, ??>",
+          "description": "Returns a new tree with the specified key and its value removed.",
+          "type": "function"
+        },
+        "foldTree": {
+          "signature": "foldTree(tree : Tree<?, ??>, init : ???, fn : (?, ??, ???) -> ???) -> ???",
+          "description": "Folds over all key-value pairs in the tree in order, accumulating a result.",
+          "type": "function"
+        }
+      }
+    },
+    "string": {
+      "signature": "string",
+      "description": "The string type in Flow9 represents an immutable sequence of Unicode characters. Strings support concatenation with the + operator and various built-in functions for searching, splitting, trimming, and converting. String literals are enclosed in double quotes with standard escape sequences.",
+      "type": "class",
+      "module": "Flow9 Runtime",
+      "members": {
+        "strlen": {
+          "signature": "strlen(s : string) -> int",
+          "description": "Returns the length of the string in characters.",
+          "type": "function"
+        },
+        "strContainsAt": {
+          "signature": "strContainsAt(str : string, pos : int, substr : string) -> bool",
+          "description": "Returns true if the substring is found at the specified position in the string.",
+          "type": "function"
+        },
+        "substring": {
+          "signature": "substring(s : string, start : int, length : int) -> string",
+          "description": "Returns a substring starting at the given index with the specified length.",
+          "type": "function"
+        },
+        "strIndexOf": {
+          "signature": "strIndexOf(str : string, substr : string) -> int",
+          "description": "Returns the index of the first occurrence of the substring, or -1 if not found.",
+          "type": "function"
+        },
+        "toLowerCase": {
+          "signature": "toLowerCase(s : string) -> string",
+          "description": "Returns a new string with all characters converted to lowercase.",
+          "type": "function"
+        }
+      }
+    },
+    "ref": {
+      "signature": "ref T",
+      "description": "A mutable reference cell in Flow9 that holds a value of type T and can be updated in place. Refs are the primary mechanism for mutable state in the otherwise functional Flow9 language. Created with ref(value), read with ^refVar (dereference), and updated with refVar := newValue.",
+      "type": "class",
+      "module": "Flow9 Runtime"
+    },
+    "maybe": {
+      "signature": "Maybe<?> ::= None | Some(value : ?)",
+      "description": "A union type representing an optional value that may or may not be present. Maybe is used throughout Flow9 for safe handling of possibly-absent values, particularly as return types from lookups in trees and arrays. Pattern matching with switch is used to extract the contained value.",
+      "type": "class",
+      "module": "Flow9 Runtime",
+      "members": {
+        "Some": {
+          "signature": "Some(value : ?) -> Maybe<?>",
+          "description": "Wraps a present value in the Maybe type, indicating the value exists.",
+          "type": "function"
+        },
+        "None": {
+          "signature": "None() -> Maybe<?>",
+          "description": "Represents the absence of a value in the Maybe type.",
+          "type": "function"
+        },
+        "either": {
+          "signature": "either(m : Maybe<?>, default : ?) -> ?",
+          "description": "Extracts the value from a Maybe, returning the default if it is None.",
+          "type": "function"
+        }
+      }
+    },
+    "int": {
+      "signature": "int",
+      "description": "A 32-bit signed integer type in Flow9 for representing whole numbers. Supports standard arithmetic operations (+, -, *, /, %), comparison operators, and bitwise operations. Integer division truncates toward zero.",
+      "type": "class",
+      "module": "Flow9 Runtime"
+    },
+    "double": {
+      "signature": "double",
+      "description": "A 64-bit double-precision floating-point number type in Flow9 for representing decimal numbers. Follows IEEE 754 standard. Supports standard arithmetic operations and mathematical functions from the math module.",
+      "type": "class",
+      "module": "Flow9 Runtime"
+    },
+    "bool": {
+      "signature": "bool",
+      "description": "A Boolean type in Flow9 with two possible values: true and false. Supports logical operators && (and), || (or), and ! (not). Used in conditional expressions, filter predicates, and control flow statements.",
+      "type": "class",
+      "module": "Flow9 Runtime"
+    }
+  }
+}