@enjoys/context-engine 1.1.0 → 1.1.2

package/data/defination/docker-compose.json

@@ -0,0 +1,347 @@
+{
+  "language": "docker-compose",
+  "definitions": {
+    "services": {
+      "signature": "services:",
+      "description": "Top-level element defining all containers (services) to run. Each service specifies an image or build context, ports, volumes, environment variables, and other container configuration.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "image": {
+      "signature": "image: <name>[:<tag>|@<digest>]",
+      "description": "Specify the Docker image to start the container from. Can reference images from a registry, a local image, or include a tag or digest.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "build": {
+      "signature": "build: <path> | build: { context: <path>, dockerfile: <file>, args: {}, target: <stage> }",
+      "description": "Configuration options applied at build time. Can be a path string to the build context, or a detailed object specifying context, dockerfile, build args, target stage, cache settings, and more.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "container_name": {
+      "signature": "container_name: <string>",
+      "description": "Specify a custom container name rather than a generated default. Because container names must be unique, you cannot scale a service with a custom container name.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "command": {
+      "signature": "command: <string> | command: [\"executable\", \"arg1\", ...]",
+      "description": "Override the default CMD declared by the container image. Can be a shell-form string or exec-form list.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "entrypoint": {
+      "signature": "entrypoint: <string> | entrypoint: [\"executable\", \"arg1\", ...]",
+      "description": "Override the default ENTRYPOINT from the image. Setting entrypoint also clears any default CMD.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "ports": {
+      "signature": "ports: [\"HOST:CONTAINER\", ...]",
+      "description": "Expose container ports. Short syntax: HOST:CONTAINER or just CONTAINER. Long syntax supports protocol, mode, host_ip, and published/target fields.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "expose": {
+      "signature": "expose: [\"<port>\", ...]",
+      "description": "Expose ports to linked services without publishing them to the host machine. Only the internal port is specified.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "environment": {
+      "signature": "environment: { KEY: value, ... } | environment: [\"KEY=value\", ...]",
+      "description": "Add environment variables to the container. Can use a mapping or a list. Boolean values (true/false/yes/no) must be quoted to avoid YAML parsing issues.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "env_file": {
+      "signature": "env_file: <path> | env_file: [<path>, ...]",
+      "description": "Add environment variables from a file. Each line in the file should be in VAR=VAL format. Lines beginning with # are comments.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "volumes": {
+      "signature": "volumes: [\"HOST:CONTAINER[:MODE]\", ...] | volumes: [{ type, source, target, ... }]",
+      "description": "Mount host paths or named volumes. Short syntax: HOST:CONTAINER:MODE. Long syntax allows specifying type (bind, volume, tmpfs, npipe), source, target, read_only, and bind/volume options.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "networks": {
+      "signature": "networks: [<network>, ...] | networks: { <network>: { aliases: [], ipv4_address: ... } }",
+      "description": "Networks to join. Can be a list of network names or a mapping with per-service network configuration like aliases and static IPs.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "depends_on": {
+      "signature": "depends_on: [<service>, ...] | depends_on: { <service>: { condition: <cond> } }",
+      "description": "Express startup and shutdown dependencies between services. Short form is a list; long form supports conditions: service_started, service_healthy, service_completed_successfully.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "restart": {
+      "signature": "restart: no | always | on-failure[:<max-retries>] | unless-stopped",
+      "description": "Restart policy for the container. 'no' never restarts, 'always' always restarts, 'on-failure' restarts on non-zero exit, 'unless-stopped' always restarts except when explicitly stopped.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "healthcheck": {
+      "signature": "healthcheck: { test: <cmd>, interval: <dur>, timeout: <dur>, retries: <n>, start_period: <dur> }",
+      "description": "Configure a check to determine if containers for this service are healthy. Test can be a string or CMD/CMD-SHELL list.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "deploy": {
+      "signature": "deploy: { replicas: <n>, resources: { limits: {}, reservations: {} }, restart_policy: {}, ... }",
+      "description": "Specify deployment and running configuration. Includes replicas, resource limits/reservations, restart policy, update/rollback config, placement constraints, and labels.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "logging": {
+      "signature": "logging: { driver: <driver>, options: { ... } }",
+      "description": "Logging configuration for the service. Supported drivers include json-file, syslog, journald, gelf, fluentd, awslogs, splunk, none.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "labels": {
+      "signature": "labels: { <key>: <value>, ... } | labels: [\"<key>=<value>\", ...]",
+      "description": "Add metadata to containers using Docker labels. Can be a mapping or a list.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "working_dir": {
+      "signature": "working_dir: <path>",
+      "description": "Override the container's working directory from the image's WORKDIR.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "user": {
+      "signature": "user: <uid>[:<gid>]",
+      "description": "Override the user used to run the container process. Format: user, user:group, uid, uid:gid.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "secrets": {
+      "signature": "secrets: [<secret>, ...] | secrets: [{ source, target, uid, gid, mode }]",
+      "description": "Grant access to secrets on a per-service basis. The secret must be defined in the top-level secrets section. Secrets are mounted at /run/secrets/<name> by default.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "configs": {
+      "signature": "configs: [<config>, ...] | configs: [{ source, target, uid, gid, mode }]",
+      "description": "Grant access to configs on a per-service basis. The config must be defined in the top-level configs section.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "network_mode": {
+      "signature": "network_mode: bridge | host | none | service:<name>",
+      "description": "Set the networking mode. 'host' uses the host's networking directly. 'service:<name>' shares another service's network namespace.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "cap_add": {
+      "signature": "cap_add: [<capability>, ...]",
+      "description": "Add container capabilities. Example capabilities: SYS_PTRACE, NET_ADMIN, SYS_ADMIN.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "cap_drop": {
+      "signature": "cap_drop: [<capability>, ...]",
+      "description": "Drop container capabilities. Common pattern: drop ALL then add back only needed capabilities.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "privileged": {
+      "signature": "privileged: true | false",
+      "description": "Give extended privileges to the container. Equivalent to docker run --privileged. Use with caution for security reasons.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "read_only": {
+      "signature": "read_only: true | false",
+      "description": "Mount the container's root filesystem as read-only. Use volumes or tmpfs for writable paths.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "security_opt": {
+      "signature": "security_opt: [\"<option>\", ...]",
+      "description": "Override the default labeling scheme for each container. Example: no-new-privileges:true, seccomp:unconfined.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "pid": {
+      "signature": "pid: host | pid: \"service:<name>\"",
+      "description": "Set the PID mode. 'host' shares the host PID namespace with the container.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "ipc": {
+      "signature": "ipc: host | shareable | service:<name>",
+      "description": "Configure IPC isolation mode. 'host' shares the host IPC namespace.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "extra_hosts": {
+      "signature": "extra_hosts: [\"<hostname>:<ip>\", ...]",
+      "description": "Add hostname mappings to the container's /etc/hosts file. Use 'host-gateway' as IP to map to the host's gateway address.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "dns": {
+      "signature": "dns: <ip> | dns: [<ip>, ...]",
+      "description": "Custom DNS server addresses.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "dns_search": {
+      "signature": "dns_search: <domain> | dns_search: [<domain>, ...]",
+      "description": "Custom DNS search domains.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "tmpfs": {
+      "signature": "tmpfs: <path> | tmpfs: [<path>, ...]",
+      "description": "Mount a temporary filesystem inside the container. Size can be limited with size option in long syntax.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "ulimits": {
+      "signature": "ulimits: { <limit>: <value> | { soft: <n>, hard: <n> } }",
+      "description": "Override the default ulimits for a container. Common limits: nofile, nproc, memlock.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "sysctls": {
+      "signature": "sysctls: { <key>: <value>, ... }",
+      "description": "Kernel parameters to set in the container. Only namespaced sysctls are supported.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "stop_signal": {
+      "signature": "stop_signal: <signal>",
+      "description": "Set an alternative signal to stop the container. Default is SIGTERM.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "stop_grace_period": {
+      "signature": "stop_grace_period: <duration>",
+      "description": "Time to wait for the container to stop gracefully before sending SIGKILL. Default is 10s.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "init": {
+      "signature": "init: true | false",
+      "description": "Run an init process (tini) inside the container that forwards signals and reaps zombie processes.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "platform": {
+      "signature": "platform: <os>/<arch>[/<variant>]",
+      "description": "Define the target platform for the container. Example: linux/amd64, linux/arm64.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "profiles": {
+      "signature": "profiles: [<profile>, ...]",
+      "description": "Define a list of named profiles for the service. Services with profiles are only started when a matching profile is activated.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "pull_policy": {
+      "signature": "pull_policy: always | never | missing | build",
+      "description": "Define when Compose should pull the image. 'always' pulls on every up, 'missing' only if not present locally, 'never' never pulls, 'build' always builds.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "extends": {
+      "signature": "extends: { file: <path>, service: <name> }",
+      "description": "Extend another service, in the current file or another, optionally overriding configuration.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "develop": {
+      "signature": "develop: { watch: [{ action: sync|rebuild|sync+restart, path: <path>, target: <path> }] }",
+      "description": "Configure file watching for live development with docker compose watch. Actions: sync (copy files), rebuild (rebuild and replace), sync+restart (copy and restart).",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "include": {
+      "signature": "include: [{ path: <file> }, ...]",
+      "description": "Include other Compose files. Allows splitting a large application into sub-Compose files managed separately.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "version": {
+      "signature": "version: '<version>'",
+      "description": "Informational Compose file format version. Deprecated — the latest Compose spec is used automatically. Common values: '3.8', '3.9', '2.4'.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "name": {
+      "signature": "name: <string>",
+      "description": "Set the project name. Defaults to the directory name. Used as a prefix for container names, networks, and volumes.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "driver": {
+      "signature": "driver: <driver_name>",
+      "description": "Driver for a top-level network or volume. Network drivers: bridge, overlay, host, none, macvlan, ipvlan. Volume drivers: local, or third-party.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "ipam": {
+      "signature": "ipam: { driver: <driver>, config: [{ subnet: <cidr> }] }",
+      "description": "Custom IPAM (IP Address Management) configuration for a network. Specify subnets, gateways, and IP ranges.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "external": {
+      "signature": "external: true",
+      "description": "Indicate that a network or volume is managed outside of Compose. Compose does not create it and raises an error if it doesn't exist.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "shm_size": {
+      "signature": "shm_size: <size>",
+      "description": "Size of the shared memory (/dev/shm). Specified as a byte value (e.g., '2gb', '256m').",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "hostname": {
+      "signature": "hostname: <string>",
+      "description": "Declare a custom hostname for the service container.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "domainname": {
+      "signature": "domainname: <string>",
+      "description": "Declare a custom domain name for the service container.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "devices": {
+      "signature": "devices: [\"<host_device>:<container_device>[:permissions]\"]",
+      "description": "List of device mappings from host to container. Permissions: r (read), w (write), m (mknod).",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "runtime": {
+      "signature": "runtime: <runtime>",
+      "description": "Specify the runtime to use for the container. Example: nvidia for GPU workloads.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "scale": {
+      "signature": "scale: <number>",
+      "description": "Set the default number of containers to deploy for this service. Deprecated in favor of deploy.replicas.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    },
+    "annotations": {
+      "signature": "annotations: { <key>: <value>, ... }",
+      "description": "Add OCI annotations to the container.",
+      "type": "keyword",
+      "module": "Compose Spec"
+    }
+  }
+}

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"
+    }
+  }
+}