@enjoys/context-engine 1.1.1 → 1.2.0

package/data/definition/dart.json

@@ -0,0 +1,360 @@
+{
+  "language": "dart",
+  "definitions": {
+    "String": {
+      "signature": "abstract class String implements Comparable<String>, Pattern",
+      "description": "A sequence of UTF-16 code units representing text in Dart. Strings are immutable and support interpolation with $variable and ${expression} syntax. The String class provides comprehensive methods for searching, splitting, trimming, padding, and transforming text.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "length": {
+          "signature": "int get length",
+          "description": "Returns the number of UTF-16 code units in the string, which may differ from the number of visible characters for non-BMP code points.",
+          "type": "property"
+        },
+        "contains": {
+          "signature": "bool contains(Pattern other, [int startIndex = 0])",
+          "description": "Returns true if this string contains a match of the specified pattern (string or RegExp) starting from the given index.",
+          "type": "method"
+        },
+        "split": {
+          "signature": "List<String> split(Pattern pattern)",
+          "description": "Splits the string at each match of the pattern and returns a list of substrings.",
+          "type": "method"
+        },
+        "substring": {
+          "signature": "String substring(int start, [int? end])",
+          "description": "Returns the substring from start index (inclusive) to end index (exclusive), or to the end if omitted.",
+          "type": "method"
+        },
+        "trim": {
+          "signature": "String trim()",
+          "description": "Returns a new string with leading and trailing whitespace removed.",
+          "type": "method"
+        },
+        "replaceAll": {
+          "signature": "String replaceAll(Pattern from, String replace)",
+          "description": "Replaces all matches of the pattern in the string with the replacement string.",
+          "type": "method"
+        },
+        "toUpperCase": {
+          "signature": "String toUpperCase()",
+          "description": "Converts all characters in the string to uppercase according to the locale-independent rules.",
+          "type": "method"
+        },
+        "startsWith": {
+          "signature": "bool startsWith(Pattern pattern, [int index = 0])",
+          "description": "Returns true if the string begins with a match of the pattern at the specified index.",
+          "type": "method"
+        }
+      }
+    },
+    "int": {
+      "signature": "abstract class int extends num",
+      "description": "An integer number type in Dart. On native platforms, values can be from -2^63 to 2^63-1. On the web, values are represented as JavaScript numbers with up to 53 bits of precision. Supports standard arithmetic operations, bitwise operations, and conversion methods.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "parse": {
+          "signature": "static int parse(String source, {int? radix, int onError(String source)?})",
+          "description": "Parses a string as an integer literal in the given radix (default 10), throwing FormatException if invalid.",
+          "type": "method"
+        },
+        "tryParse": {
+          "signature": "static int? tryParse(String source, {int? radix})",
+          "description": "Parses a string as an integer, returning null instead of throwing if the string is not a valid integer.",
+          "type": "method"
+        },
+        "toDouble": {
+          "signature": "double toDouble()",
+          "description": "Converts this integer to a double-precision floating-point representation.",
+          "type": "method"
+        },
+        "toString": {
+          "signature": "String toString()",
+          "description": "Returns the decimal string representation of this integer.",
+          "type": "method"
+        },
+        "toRadixString": {
+          "signature": "String toRadixString(int radix)",
+          "description": "Converts this integer to a string representation in the given radix (base 2-36).",
+          "type": "method"
+        }
+      }
+    },
+    "double": {
+      "signature": "abstract class double extends num",
+      "description": "A double-precision 64-bit IEEE 754 floating-point number in Dart. Doubles are used for all floating-point arithmetic and include special values like double.infinity, double.negativeInfinity, and double.nan for handling edge cases.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "parse": {
+          "signature": "static double parse(String source, [double onError(String source)?])",
+          "description": "Parses the source string as a double literal, throwing FormatException if it is not a valid representation.",
+          "type": "method"
+        },
+        "toStringAsFixed": {
+          "signature": "String toStringAsFixed(int fractionDigits)",
+          "description": "Returns the decimal string representation with exactly fractionDigits digits after the decimal point.",
+          "type": "method"
+        },
+        "round": {
+          "signature": "int round()",
+          "description": "Returns the integer closest to this double, rounding half-values away from zero.",
+          "type": "method"
+        }
+      }
+    },
+    "List": {
+      "signature": "abstract class List<E> implements EfficientLengthIterable<E>",
+      "description": "An indexable collection of objects with a zero-based integer index. Lists are the most commonly used collection type in Dart for ordered data. They can be fixed-length (created with List.filled) or growable (created with [] literal or List.empty(growable: true)).",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "add": {
+          "signature": "void add(E value)",
+          "description": "Appends a single element to the end of the list, increasing its length by one.",
+          "type": "method"
+        },
+        "addAll": {
+          "signature": "void addAll(Iterable<E> iterable)",
+          "description": "Appends all objects of the iterable to the end of this list.",
+          "type": "method"
+        },
+        "where": {
+          "signature": "Iterable<E> where(bool test(E element))",
+          "description": "Returns a lazy iterable of all elements that satisfy the given predicate test function.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "Iterable<T> map<T>(T toElement(E e))",
+          "description": "Returns a lazy iterable with each element transformed by the given function.",
+          "type": "method"
+        },
+        "sort": {
+          "signature": "void sort([int compare(E a, E b)?])",
+          "description": "Sorts the list in-place according to the compare function, or natural ordering if omitted.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "bool contains(Object? element)",
+          "description": "Returns true if the collection contains an element equal to the given element.",
+          "type": "method"
+        },
+        "removeAt": {
+          "signature": "E removeAt(int index)",
+          "description": "Removes and returns the element at the given index, shifting subsequent elements down.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "void forEach(void action(E element))",
+          "description": "Applies the given function to each element of the list in iteration order.",
+          "type": "method"
+        }
+      }
+    },
+    "Map": {
+      "signature": "abstract class Map<K, V>",
+      "description": "A collection of key-value pairs from which values are retrieved using their associated keys. Maps in Dart support generic key and value types, iteration over entries, and various constructors including Map.from, Map.of, and Map.fromIterables.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "containsKey": {
+          "signature": "bool containsKey(Object? key)",
+          "description": "Returns true if this map contains the given key.",
+          "type": "method"
+        },
+        "putIfAbsent": {
+          "signature": "V putIfAbsent(K key, V ifAbsent())",
+          "description": "Looks up the value for the key, or adds a new entry if the key is absent by calling ifAbsent.",
+          "type": "method"
+        },
+        "remove": {
+          "signature": "V? remove(Object? key)",
+          "description": "Removes the key and its associated value from the map and returns the value.",
+          "type": "method"
+        },
+        "forEach": {
+          "signature": "void forEach(void action(K key, V value))",
+          "description": "Applies the given function to each key-value pair in the map.",
+          "type": "method"
+        },
+        "entries": {
+          "signature": "Iterable<MapEntry<K, V>> get entries",
+          "description": "Returns an iterable of all key-value pairs as MapEntry objects.",
+          "type": "property"
+        },
+        "keys": {
+          "signature": "Iterable<K> get keys",
+          "description": "Returns an iterable of all keys in the map.",
+          "type": "property"
+        }
+      }
+    },
+    "Set": {
+      "signature": "abstract class Set<E> extends EfficientLengthIterable<E>",
+      "description": "A collection of unique objects where each object can occur only once. Sets provide efficient membership testing (contains) and support union, intersection, and difference operations for combining sets.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "add": {
+          "signature": "bool add(E value)",
+          "description": "Adds the value to the set. Returns true if the value was not already in the set.",
+          "type": "method"
+        },
+        "contains": {
+          "signature": "bool contains(Object? value)",
+          "description": "Returns true if the set contains the specified value.",
+          "type": "method"
+        },
+        "union": {
+          "signature": "Set<E> union(Set<E> other)",
+          "description": "Returns a new set containing all elements from both sets.",
+          "type": "method"
+        },
+        "intersection": {
+          "signature": "Set<E> intersection(Set<Object?> other)",
+          "description": "Returns a new set with only the elements present in both sets.",
+          "type": "method"
+        },
+        "difference": {
+          "signature": "Set<E> difference(Set<Object?> other)",
+          "description": "Returns a new set with elements in this set that are not in the other set.",
+          "type": "method"
+        }
+      }
+    },
+    "Future": {
+      "signature": "abstract class Future<T>",
+      "description": "An object representing a delayed computation whose result will be available at some later time. Futures are the foundation of Dart's asynchronous programming model, used with async/await syntax for non-blocking I/O, network requests, file operations, and any operation that takes time to complete.",
+      "type": "class",
+      "module": "dart:async",
+      "members": {
+        "then": {
+          "signature": "Future<R> then<R>(FutureOr<R> onValue(T value), {Function? onError})",
+          "description": "Registers a callback to be called when this future completes with a value, returning a new future for chaining.",
+          "type": "method"
+        },
+        "catchError": {
+          "signature": "Future<T> catchError(Function onError, {bool test(Object error)?})",
+          "description": "Handles errors emitted by this future, optionally filtering by error type with the test function.",
+          "type": "method"
+        },
+        "whenComplete": {
+          "signature": "Future<T> whenComplete(FutureOr<void> action())",
+          "description": "Registers a function to be called when the future completes, whether with a value or an error (like finally).",
+          "type": "method"
+        },
+        "timeout": {
+          "signature": "Future<T> timeout(Duration timeLimit, {FutureOr<T> onTimeout()?})",
+          "description": "Returns a future that completes with a timeout error if this future does not complete within the time limit.",
+          "type": "method"
+        },
+        "wait": {
+          "signature": "static Future<List<T>> wait<T>(Iterable<Future<T>> futures, {bool eagerError = false})",
+          "description": "Waits for multiple futures to complete and returns their results as a list in the same order.",
+          "type": "method"
+        }
+      }
+    },
+    "Stream": {
+      "signature": "abstract class Stream<T>",
+      "description": "A source of asynchronous data events that delivers a sequence of values over time. Streams are used for handling continuous data sources like user input events, WebSocket messages, file reads, and timer ticks. Supports single-subscription and broadcast stream types.",
+      "type": "class",
+      "module": "dart:async",
+      "members": {
+        "listen": {
+          "signature": "StreamSubscription<T> listen(void onData(T event)?, {Function? onError, void onDone()?, bool? cancelOnError})",
+          "description": "Subscribes to events from this stream, providing callbacks for data, error, and completion events.",
+          "type": "method"
+        },
+        "map": {
+          "signature": "Stream<S> map<S>(S convert(T event))",
+          "description": "Creates a new stream that transforms each data event from this stream using the given function.",
+          "type": "method"
+        },
+        "where": {
+          "signature": "Stream<T> where(bool test(T event))",
+          "description": "Creates a new stream that only includes data events that satisfy the predicate.",
+          "type": "method"
+        },
+        "first": {
+          "signature": "Future<T> get first",
+          "description": "Returns a future that completes with the first element of the stream.",
+          "type": "property"
+        },
+        "toList": {
+          "signature": "Future<List<T>> toList()",
+          "description": "Collects all data events from the stream into a list, returned when the stream closes.",
+          "type": "method"
+        }
+      }
+    },
+    "Iterable": {
+      "signature": "abstract class Iterable<E>",
+      "description": "A collection of values that can be accessed sequentially. Iterable is the base interface for all collections in Dart and defines lazy operations like map, where, expand, take, and skip that are only evaluated when the result is iterated.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "map": {
+          "signature": "Iterable<T> map<T>(T toElement(E e))",
+          "description": "Returns a lazy iterable where each element is the result of applying the given function.",
+          "type": "method"
+        },
+        "where": {
+          "signature": "Iterable<E> where(bool test(E element))",
+          "description": "Returns a lazy iterable of elements that satisfy the predicate test function.",
+          "type": "method"
+        },
+        "fold": {
+          "signature": "T fold<T>(T initialValue, T combine(T previousValue, E element))",
+          "description": "Reduces the collection to a single value by iteratively combining the elements with an accumulator.",
+          "type": "method"
+        },
+        "toList": {
+          "signature": "List<E> toList({bool growable = true})",
+          "description": "Creates a List containing the elements of this iterable in iteration order.",
+          "type": "method"
+        }
+      }
+    },
+    "DateTime": {
+      "signature": "class DateTime implements Comparable<DateTime>",
+      "description": "An instant in time representing a date and time-of-day with microsecond precision. DateTime objects can represent UTC or local time and provide methods for date arithmetic, comparison, formatting, and extracting components like year, month, day, hour, minute, and second.",
+      "type": "class",
+      "module": "dart:core",
+      "members": {
+        "now": {
+          "signature": "DateTime.now()",
+          "description": "Creates a DateTime object representing the current date and time in the local time zone.",
+          "type": "method"
+        },
+        "parse": {
+          "signature": "static DateTime parse(String formattedString)",
+          "description": "Parses a string conforming to a subset of ISO 8601 format into a DateTime object.",
+          "type": "method"
+        },
+        "difference": {
+          "signature": "Duration difference(DateTime other)",
+          "description": "Returns the difference between this and another DateTime as a Duration object.",
+          "type": "method"
+        },
+        "add": {
+          "signature": "DateTime add(Duration duration)",
+          "description": "Returns a new DateTime with the given duration added to this one.",
+          "type": "method"
+        },
+        "isBefore": {
+          "signature": "bool isBefore(DateTime other)",
+          "description": "Returns true if this DateTime occurs before the other DateTime.",
+          "type": "method"
+        },
+        "toIso8601String": {
+          "signature": "String toIso8601String()",
+          "description": "Returns an ISO-8601 full-precision extended format representation of this DateTime.",
+          "type": "method"
+        }
+      }
+    }
+  }
+}

package/data/definition/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/definition/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"
+    }
+  }
+}