From adf56349e869112a22349fac8dedc78e14f6dcaa Mon Sep 17 00:00:00 2001 From: Raphael Date: Thu, 20 Nov 2025 10:50:03 +0100 Subject: [PATCH 01/14] feat: added alias and displayName for data-types --- .../array/http_header_map.proto.json | 76 +++++++----- .../object/http_adapter_input.proto.json | 14 ++- .../object/http_header_entry.proto.json | 82 +++++++------ .../data_type/object/http_request.proto.json | 114 ++++++++++-------- .../data_type/object/http_response.proto.json | 16 ++- .../data_type/type/http_method.proto.json | 16 ++- .../type/http_status_code.proto.json | 16 ++- .../http/data_type/type/http_url.proto.json | 16 ++- .../standard/data_type/array/array.proto.json | 16 ++- .../data_type/node/comparator.proto.json | 16 ++- .../data_type/node/consumer.proto.json | 16 ++- .../data_type/node/predicate.proto.json | 16 ++- .../data_type/node/runnable.proto.json | 16 ++- .../data_type/node/transform.proto.json | 80 ++++++------ .../data_type/object/object.proto.json | 16 ++- .../data_type/primitive/boolean.proto.json | 16 ++- .../data_type/primitive/number.proto.json | 16 ++- .../data_type/primitive/text.proto.json | 16 ++- .../data_type/type/text_encoding.proto.json | 54 +++++---- 19 files changed, 428 insertions(+), 200 deletions(-) diff --git a/definitions/http/data_type/array/http_header_map.proto.json b/definitions/http/data_type/array/http_header_map.proto.json index d533410d..9f4c9e41 100644 --- a/definitions/http/data_type/array/http_header_map.proto.json +++ b/definitions/http/data_type/array/http_header_map.proto.json @@ -1,33 +1,45 @@ { - "variant": "ARRAY", - "identifier": "HTTP_HEADER_MAP", - "name": [ - { - "code": "en-US", - "content": "HTTP Headers" - } - ], - "rules": [ - { - "parentType": { - "parentType": { - "genericType": { - "dataTypeIdentifier": "ARRAY", - "genericMappers": [ - { - "source": [ - { - "dataTypeIdentifier": "HTTP_HEADER_ENTRY" - } - ], - "target": "T", - "genericCombinations": [] - } - ] - } - } - } - } - ], - "genericKeys": [] -} \ No newline at end of file + "variant": "ARRAY", + "identifier": "HTTP_HEADER_MAP", + "name": [ + { + "code": "en-US", + "content": "HTTP Headers" + } + ], + "alias": [ + { + "code": "en-US", + "content": "http;headers" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "HTTP Headers" + } + ], + "rules": [ + { + "parentType": { + "parentType": { + "genericType": { + "dataTypeIdentifier": "ARRAY", + "genericMappers": [ + { + "source": [ + { + "dataTypeIdentifier": "HTTP_HEADER_ENTRY" + } + ], + "target": "T", + "genericCombinations": [] + } + ] + } + } + } + } + ], + "genericKeys": [] +} diff --git a/definitions/http/data_type/object/http_adapter_input.proto.json b/definitions/http/data_type/object/http_adapter_input.proto.json index e658bb3a..717bb4e6 100644 --- a/definitions/http/data_type/object/http_adapter_input.proto.json +++ b/definitions/http/data_type/object/http_adapter_input.proto.json @@ -7,6 +7,18 @@ "content": "HTTP Adapter Input" } ], + "alias": [ + { + "code": "en-US", + "content": "http;adapter;input" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "HTTP Adapter Input" + } + ], "rules": [ { "containsKey": { @@ -33,4 +45,4 @@ } ], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/http/data_type/object/http_header_entry.proto.json b/definitions/http/data_type/object/http_header_entry.proto.json index b25630e3..1bb6fe78 100644 --- a/definitions/http/data_type/object/http_header_entry.proto.json +++ b/definitions/http/data_type/object/http_header_entry.proto.json @@ -1,36 +1,48 @@ { - "variant": "OBJECT", - "identifier": "HTTP_HEADER_ENTRY", - "name": [ - { - "code": "en-US", - "content": "HTTP Header Entry" - } - ], - "rules": [ - { - "containsKey": { - "key": "key", - "dataTypeIdentifier": { - "dataTypeIdentifier": "TEXT" - } - } - }, - { - "containsKey": { - "key": "value", - "dataTypeIdentifier": { - "dataTypeIdentifier": "TEXT" - } - } - }, - { - "parentType": { - "parentType": { - "dataTypeIdentifier": "OBJECT" - } - } - } - ], - "genericKeys": [] -} \ No newline at end of file + "variant": "OBJECT", + "identifier": "HTTP_HEADER_ENTRY", + "name": [ + { + "code": "en-US", + "content": "HTTP Header Entry" + } + ], + "alias": [ + { + "code": "en-US", + "content": "http;header;entry" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "HTTP Header Entry" + } + ], + "rules": [ + { + "containsKey": { + "key": "key", + "dataTypeIdentifier": { + "dataTypeIdentifier": "TEXT" + } + } + }, + { + "containsKey": { + "key": "value", + "dataTypeIdentifier": { + "dataTypeIdentifier": "TEXT" + } + } + }, + { + "parentType": { + "parentType": { + "dataTypeIdentifier": "OBJECT" + } + } + } + ], + "genericKeys": [] +} diff --git a/definitions/http/data_type/object/http_request.proto.json b/definitions/http/data_type/object/http_request.proto.json index 08c6fc10..f0d0f82e 100644 --- a/definitions/http/data_type/object/http_request.proto.json +++ b/definitions/http/data_type/object/http_request.proto.json @@ -1,52 +1,64 @@ { - "variant": "OBJECT", - "identifier": "HTTP_REQUEST", - "name": [ - { - "code": "en-US", - "content": "HTTP Request" - } - ], - "rules": [ - { - "containsKey": { - "key": "method", - "dataTypeIdentifier": { - "dataTypeIdentifier": "HTTP_METHOD" - } - } - }, - { - "containsKey": { - "key": "url", - "dataTypeIdentifier": { - "dataTypeIdentifier": "HTTP_URL" - } - } - }, - { - "containsKey": { - "key": "body", - "dataTypeIdentifier": { - "dataTypeIdentifier": "OBJECT" - } - } - }, - { - "containsKey": { - "key": "headers", - "dataTypeIdentifier": { - "dataTypeIdentifier": "HTTP_HEADER_MAP" - } - } - }, - { - "parentType": { - "parentType": { - "dataTypeIdentifier": "OBJECT" - } - } - } - ], - "genericKeys": [] -} \ No newline at end of file + "variant": "OBJECT", + "identifier": "HTTP_REQUEST", + "name": [ + { + "code": "en-US", + "content": "HTTP Request" + } + ], + "alias": [ + { + "code": "en-US", + "content": "http;request" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "HTTP Request" + } + ], + "rules": [ + { + "containsKey": { + "key": "method", + "dataTypeIdentifier": { + "dataTypeIdentifier": "HTTP_METHOD" + } + } + }, + { + "containsKey": { + "key": "url", + "dataTypeIdentifier": { + "dataTypeIdentifier": "HTTP_URL" + } + } + }, + { + "containsKey": { + "key": "body", + "dataTypeIdentifier": { + "dataTypeIdentifier": "OBJECT" + } + } + }, + { + "containsKey": { + "key": "headers", + "dataTypeIdentifier": { + "dataTypeIdentifier": "HTTP_HEADER_MAP" + } + } + }, + { + "parentType": { + "parentType": { + "dataTypeIdentifier": "OBJECT" + } + } + } + ], + "genericKeys": [] +} diff --git a/definitions/http/data_type/object/http_response.proto.json b/definitions/http/data_type/object/http_response.proto.json index 61a3f2de..eef1c749 100644 --- a/definitions/http/data_type/object/http_response.proto.json +++ b/definitions/http/data_type/object/http_response.proto.json @@ -7,7 +7,19 @@ "content": "HTTP Response" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "http;response;object" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "HTTP Respons" + } + ], + "rules": [ { "containsKey": { "key": "headers", @@ -33,4 +45,4 @@ } ], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/http/data_type/type/http_method.proto.json b/definitions/http/data_type/type/http_method.proto.json index 621bd493..8e59a4a1 100644 --- a/definitions/http/data_type/type/http_method.proto.json +++ b/definitions/http/data_type/type/http_method.proto.json @@ -7,7 +7,19 @@ "content": "HTTP Method" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "http;method;get;post;put;delete;path;head" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "HTTP Method" + } + ], + "rules": [ { "itemOfCollection": { "items": [ @@ -34,4 +46,4 @@ } ], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/http/data_type/type/http_status_code.proto.json b/definitions/http/data_type/type/http_status_code.proto.json index 54349899..5d42c601 100644 --- a/definitions/http/data_type/type/http_status_code.proto.json +++ b/definitions/http/data_type/type/http_status_code.proto.json @@ -7,7 +7,19 @@ "content": "HTTP Status Code" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "http;status;code" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "HTTP Status Code" + } + ], + "rules": [ { "numberRange": { "from": 100, @@ -16,4 +28,4 @@ } ], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/http/data_type/type/http_url.proto.json b/definitions/http/data_type/type/http_url.proto.json index 5ea2d967..c5a9bd9e 100644 --- a/definitions/http/data_type/type/http_url.proto.json +++ b/definitions/http/data_type/type/http_url.proto.json @@ -7,7 +7,19 @@ "content": "HTTP Route" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "http;route;url" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "HTTP Route" + } + ], + "rules": [ { "regex": { "pattern": "^/\\w+(?:[.:~-]\\w+)*(?:/\\w+(?:[.:~-]\\w+)*)*$" @@ -15,4 +27,4 @@ } ], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/array/array.proto.json b/definitions/standard/data_type/array/array.proto.json index 742248ad..1bdca048 100644 --- a/definitions/standard/data_type/array/array.proto.json +++ b/definitions/standard/data_type/array/array.proto.json @@ -7,7 +7,19 @@ "content": "Generic Array" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "list;array;collection" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "List of ${T}" + } + ], + "rules": [ { "containsType": { "dataTypeIdentifier": { @@ -19,4 +31,4 @@ "genericKeys": [ "T" ] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/node/comparator.proto.json b/definitions/standard/data_type/node/comparator.proto.json index 7998332a..44d2b378 100644 --- a/definitions/standard/data_type/node/comparator.proto.json +++ b/definitions/standard/data_type/node/comparator.proto.json @@ -7,7 +7,19 @@ "content": "Comparator" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "compare;comparator" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Compare ${I}" + } + ], + "rules": [ { "returnType": { "dataTypeIdentifier": { @@ -37,4 +49,4 @@ "genericKeys": [ "I" ] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/node/consumer.proto.json b/definitions/standard/data_type/node/consumer.proto.json index 4dbed35b..35b3a9ef 100644 --- a/definitions/standard/data_type/node/consumer.proto.json +++ b/definitions/standard/data_type/node/consumer.proto.json @@ -7,7 +7,19 @@ "content": "Consumer" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "use;consumer;consume;lambda" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Use ${T}" + } + ], + "rules": [ { "inputTypes": { "inputTypes": [ @@ -24,4 +36,4 @@ "genericKeys": [ "T" ] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/node/predicate.proto.json b/definitions/standard/data_type/node/predicate.proto.json index 16e3dba9..613dc433 100644 --- a/definitions/standard/data_type/node/predicate.proto.json +++ b/definitions/standard/data_type/node/predicate.proto.json @@ -7,7 +7,19 @@ "content": "Predicate" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "predicate" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Predicate of ${T}" + } + ], + "rules": [ { "returnType": { "dataTypeIdentifier": { @@ -31,4 +43,4 @@ "genericKeys": [ "T" ] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/node/runnable.proto.json b/definitions/standard/data_type/node/runnable.proto.json index e87d0f24..500427d9 100644 --- a/definitions/standard/data_type/node/runnable.proto.json +++ b/definitions/standard/data_type/node/runnable.proto.json @@ -7,6 +7,18 @@ "content": "Node" } ], - "rules": [], + "alias": [ + { + "code": "en-US", + "content": "node;function" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Node" + } + ], + "rules": [], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/node/transform.proto.json b/definitions/standard/data_type/node/transform.proto.json index c66db1ba..42cf0a5c 100644 --- a/definitions/standard/data_type/node/transform.proto.json +++ b/definitions/standard/data_type/node/transform.proto.json @@ -1,35 +1,47 @@ { - "variant": "NODE", - "identifier": "TRANSFORM", - "name": [ - { - "code": "en-US", - "content": "Transform" - } - ], - "rules": [ - { - "returnType": { - "dataTypeIdentifier": { - "genericKey": "R" - } - } - }, - { - "inputTypes": { - "inputTypes": [ - { - "dataTypeIdentifier": { - "genericKey": "I" - }, - "inputIdentifier": "transform" - } - ] - } - } - ], - "genericKeys": [ - "I", - "R" - ] -} \ No newline at end of file + "variant": "NODE", + "identifier": "TRANSFORM", + "name": [ + { + "code": "en-US", + "content": "Transform" + } + ], + "alias": [ + { + "code": "en-US", + "content": "transform" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Transform §{I} to ${R}" + } + ], + "rules": [ + { + "returnType": { + "dataTypeIdentifier": { + "genericKey": "R" + } + } + }, + { + "inputTypes": { + "inputTypes": [ + { + "dataTypeIdentifier": { + "genericKey": "I" + }, + "inputIdentifier": "transform" + } + ] + } + } + ], + "genericKeys": [ + "I", + "R" + ] +} diff --git a/definitions/standard/data_type/object/object.proto.json b/definitions/standard/data_type/object/object.proto.json index b1495afe..cb9ded68 100644 --- a/definitions/standard/data_type/object/object.proto.json +++ b/definitions/standard/data_type/object/object.proto.json @@ -7,6 +7,18 @@ "content": "Object" } ], - "rules": [], + "alias": [ + { + "code": "en-US", + "content": "object;struct;data" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Object" + } + ], + "rules": [], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/primitive/boolean.proto.json b/definitions/standard/data_type/primitive/boolean.proto.json index 0af3072c..b9b67680 100644 --- a/definitions/standard/data_type/primitive/boolean.proto.json +++ b/definitions/standard/data_type/primitive/boolean.proto.json @@ -7,7 +7,19 @@ "content": "Boolean" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "bool;boolean;bit" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Boolean" + } + ], + "rules": [ { "regex": { "pattern": "^(true|false)$" @@ -15,4 +27,4 @@ } ], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/primitive/number.proto.json b/definitions/standard/data_type/primitive/number.proto.json index b595c38c..22b2d2ec 100644 --- a/definitions/standard/data_type/primitive/number.proto.json +++ b/definitions/standard/data_type/primitive/number.proto.json @@ -7,7 +7,19 @@ "content": "Number" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "number;integer;float;double;long" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Number" + } + ], + "rules": [ { "regex": { "pattern": "^(?:-(?:[1-9](?:\\d{0,2}(?:,\\d{3})+|\\d*))|(?:0|(?:[1-9](?:\\d{0,2}(?:,\\d{3})+|\\d*))))(?:.\\d+|)$" @@ -15,4 +27,4 @@ } ], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/primitive/text.proto.json b/definitions/standard/data_type/primitive/text.proto.json index ce40a190..6b4e92a5 100644 --- a/definitions/standard/data_type/primitive/text.proto.json +++ b/definitions/standard/data_type/primitive/text.proto.json @@ -7,7 +7,19 @@ "content": "Text" } ], - "rules": [ + "alias": [ + { + "code": "en-US", + "content": "text;char;literal;string" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Text" + } + ], + "rules": [ { "regex": { "pattern": "[\\s\\S]*" @@ -15,4 +27,4 @@ } ], "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/standard/data_type/type/text_encoding.proto.json b/definitions/standard/data_type/type/text_encoding.proto.json index 1d829b24..662d2138 100644 --- a/definitions/standard/data_type/type/text_encoding.proto.json +++ b/definitions/standard/data_type/type/text_encoding.proto.json @@ -1,22 +1,34 @@ { - "variant": "TYPE", - "identifier": "TEXT_ENCODING", - "name": [ - { - "code": "en-US", - "content": "Text Encoding" - } - ], - "rules": [ - { - "itemOfCollection": { - "items": [ - { - "stringValue": "BASE64" - } - ] - } - } - ], - "genericKeys": [] -} \ No newline at end of file + "variant": "TYPE", + "identifier": "TEXT_ENCODING", + "name": [ + { + "code": "en-US", + "content": "Text Encoding" + } + ], + "alias": [ + { + "code": "en-US", + "content": "text;encoding;base64" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Text Encoding" + } + ], + "rules": [ + { + "itemOfCollection": { + "items": [ + { + "stringValue": "BASE64" + } + ] + } + } + ], + "genericKeys": [] +} From 3a9e3222b66dc79217b296d5a5de4e6f8f825b41 Mon Sep 17 00:00:00 2001 From: Raphael Date: Thu, 20 Nov 2025 10:50:16 +0100 Subject: [PATCH 02/14] dependencies: updated tucana to 0.0.41 --- Cargo.lock | 4 ++-- Cargo.toml | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index ec2b12be..1d4f54b9 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2212,9 +2212,9 @@ checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" [[package]] name = "tucana" -version = "0.0.40" +version = "0.0.41" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "565d382969ce8de8484d22516808cfef658710a6f3342a566ad1e247ccb852cf" +checksum = "834bc82319219cd4a6a70a82e9be1353c673a70e3606da73a3851f558f96bd01" dependencies = [ "pbjson", "pbjson-build", diff --git a/Cargo.toml b/Cargo.toml index f58bbcda..926bb510 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -8,7 +8,7 @@ edition = "2024" [workspace.dependencies] serde = "1.0.219" serde_json = "1.0.140" -tucana = "0.0.40" +tucana = "0.0.41" clap = "4.5.41" colored = "3.0" tabled = "0.20" @@ -20,4 +20,4 @@ zip = "6.0.0" bytes = "1.10.1" prost = "0.14.1" walkdir = "2.5.0" -log = "0.4.28" \ No newline at end of file +log = "0.4.28" From 7441e3c81bdc50328da284921857b9e8b2bb1e25 Mon Sep 17 00:00:00 2001 From: Raphael Date: Thu, 20 Nov 2025 10:58:34 +0100 Subject: [PATCH 03/14] feat: added alias and displayMessage for FlowType --- definitions/http/flow_type/http.proto.json | 170 +++++++++++---------- 1 file changed, 91 insertions(+), 79 deletions(-) diff --git a/definitions/http/flow_type/http.proto.json b/definitions/http/flow_type/http.proto.json index e894e9ad..35d3a40b 100644 --- a/definitions/http/flow_type/http.proto.json +++ b/definitions/http/flow_type/http.proto.json @@ -1,80 +1,92 @@ { - "identifier": "HTTP", - "settings": [ - { - "identifier": "HTTP_URL", - "unique": false, - "dataTypeIdentifier": "HTTP_URL", - "defaultValue": null, - "name": [ - { - "code": "en-US", - "content": "URL" - } - ], - "description": [ - { - "code": "en-US", - "content": "Specifies the HTTP URL endpoint." - } - ] - }, - { - "identifier": "HTTP_METHOD", - "unique": false, - "dataTypeIdentifier": "HTTP_METHOD", - "defaultValue": null, - "name": [ - { - "code": "en-US", - "content": "Method" - } - ], - "description": [ - { - "code": "en-US", - "content": "Specifies the HTTP request method (e.g., GET, POST, PUT, DELETE)." - } - ] - }, - { - "identifier": "HTTP_HOST", - "unique": false, - "dataTypeIdentifier": "TEXT", - "defaultValue": null, - "name": [ - { - "code": "en-US", - "content": "Host" - } - ], - "description": [ - { - "code": "en-US", - "content": "Specifies the target host name or IP address." - } - ] - } - ], - "inputTypeIdentifier": "HTTP_ADAPTER_INPUT", - "returnTypeIdentifier": "HTTP_RESPONSE", - "editable": false, - "name": [ - { - "code": "en-US", - "content": "Rest Endpoint" - } - ], - "description": [ - { - "code": "en-US", - "content": "A REST API is a web service that lets clients interact with data on a server using standard HTTP methods like GET, POST, PUT, and DELETE usually returning results in JSON format." - } - ], - "documentation": [ - { - "code": "en-US", - "content": "A REST API is a web service that lets clients interact with data on a server using standard HTTP methods like GET, POST, PUT, and DELETE usually returning results in JSON format." - } - ] -} \ No newline at end of file + "identifier": "HTTP", + "settings": [ + { + "identifier": "HTTP_URL", + "unique": false, + "dataTypeIdentifier": "HTTP_URL", + "defaultValue": null, + "name": [ + { + "code": "en-US", + "content": "URL" + } + ], + "description": [ + { + "code": "en-US", + "content": "Specifies the HTTP URL endpoint." + } + ] + }, + { + "identifier": "HTTP_METHOD", + "unique": false, + "dataTypeIdentifier": "HTTP_METHOD", + "defaultValue": null, + "name": [ + { + "code": "en-US", + "content": "Method" + } + ], + "description": [ + { + "code": "en-US", + "content": "Specifies the HTTP request method (e.g., GET, POST, PUT, DELETE)." + } + ] + }, + { + "identifier": "HTTP_HOST", + "unique": false, + "dataTypeIdentifier": "TEXT", + "defaultValue": null, + "name": [ + { + "code": "en-US", + "content": "Host" + } + ], + "description": [ + { + "code": "en-US", + "content": "Specifies the target host name or IP address." + } + ] + } + ], + "inputTypeIdentifier": "HTTP_ADAPTER_INPUT", + "returnTypeIdentifier": "HTTP_RESPONSE", + "editable": false, + "name": [ + { + "code": "en-US", + "content": "Rest Endpoint" + } + ], + "description": [ + { + "code": "en-US", + "content": "A REST API is a web service that lets clients interact with data on a server using standard HTTP methods like GET, POST, PUT, and DELETE usually returning results in JSON format." + } + ], + "documentation": [ + { + "code": "en-US", + "content": "A REST API is a web service that lets clients interact with data on a server using standard HTTP methods like GET, POST, PUT, and DELETE usually returning results in JSON format." + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "On ${method} request to §{route}" + } + ], + "alias": [ + { + "code": "en-US", + "content": "http;rest;route;web;webhook" + } + ] +} From 3e518df7629b06283328831b8c78cfae07d093f4 Mon Sep 17 00:00:00 2001 From: Raphael Date: Thu, 20 Nov 2025 15:04:58 +0100 Subject: [PATCH 04/14] feat: added alias and displayMessage for every function --- .../control/http_control_respond.proto.json | 14 +++++++++++++- .../request/http_request_create.proto.json | 14 +++++++++++++- .../response/http_response_create.proto.json | 14 +++++++++++++- .../array/std_array_at.proto.json | 14 +++++++++++++- .../array/std_array_concat.proto.json | 14 +++++++++++++- .../array/std_array_filter.proto.json | 14 +++++++++++++- .../array/std_array_find.proto.json | 14 +++++++++++++- .../array/std_array_find_index.proto.json | 14 +++++++++++++- .../array/std_array_find_last.proto.json | 14 +++++++++++++- .../array/std_array_first.proto.json | 14 +++++++++++++- .../array/std_array_flat.proto.json | 14 +++++++++++++- .../array/std_array_for_each.proto.json | 14 +++++++++++++- .../array/std_array_index_of.proto.json | 14 +++++++++++++- .../array/std_array_is_empty.proto.json | 14 +++++++++++++- .../array/std_array_join.proto.json | 16 ++++++++++++++-- .../array/std_array_last.proto.json | 14 +++++++++++++- .../array/std_array_map.proto.json | 14 +++++++++++++- .../array/std_array_max.proto.json | 14 +++++++++++++- .../array/std_array_min.proto.json | 14 +++++++++++++- .../array/std_array_pop.proto.json | 14 +++++++++++++- .../array/std_array_push.proto.json | 14 +++++++++++++- .../array/std_array_remove.proto.json | 14 +++++++++++++- .../array/std_array_reverse.proto.json | 14 +++++++++++++- .../array/std_array_size.proto.json | 14 +++++++++++++- .../array/std_array_sort.proto.json | 14 +++++++++++++- .../array/std_array_sort_reverse.proto.json | 12 ++++++++++++ .../array/std_array_sum.proto.json | 14 +++++++++++++- .../array/std_array_to_unique.proto.json | 14 +++++++++++++- .../boolean/std_boolean_as_number.proto.json | 14 +++++++++++++- .../boolean/std_boolean_as_text.proto.json | 14 +++++++++++++- .../boolean/std_boolean_from_number.proto.json | 14 +++++++++++++- .../boolean/std_boolean_from_text.proto.json | 14 +++++++++++++- .../boolean/std_boolean_is_equal.proto.json | 14 +++++++++++++- .../boolean/std_boolean_negate.proto.json | 14 +++++++++++++- .../control/std_control_if.proto.json | 12 ++++++++++++ .../control/std_control_if_else.proto.json | 12 ++++++++++++ .../control/std_control_return.proto.json | 14 +++++++++++++- .../control/std_control_stop.proto.json | 14 +++++++++++++- .../number/std_number_abs.proto.json | 14 +++++++++++++- .../number/std_number_add.proto.json | 14 +++++++++++++- .../number/std_number_arccos.proto.json | 14 +++++++++++++- .../number/std_number_arcsin.proto.json | 14 +++++++++++++- .../number/std_number_arctan.proto.json | 14 +++++++++++++- .../number/std_number_as_text.proto.json | 14 +++++++++++++- .../number/std_number_clamp.proto.json | 14 +++++++++++++- .../number/std_number_cos.proto.json | 14 +++++++++++++- .../number/std_number_cosh.proto.json | 14 +++++++++++++- .../number/std_number_divide.proto.json | 14 +++++++++++++- .../number/std_number_euler.proto.json | 14 +++++++++++++- .../number/std_number_exponential.proto.json | 14 +++++++++++++- .../number/std_number_from_text.proto.json | 14 +++++++++++++- .../number/std_number_infinity.proto.json | 14 +++++++++++++- .../number/std_number_is_equal.proto.json | 14 +++++++++++++- .../number/std_number_is_greater.proto.json | 14 +++++++++++++- .../number/std_number_is_less.proto.json | 14 +++++++++++++- .../number/std_number_is_positive.proto.json | 14 +++++++++++++- .../number/std_number_is_zero.proto.json | 14 +++++++++++++- .../number/std_number_ln.proto.json | 14 +++++++++++++- .../number/std_number_log.proto.json | 14 +++++++++++++- .../number/std_number_max.proto.json | 14 +++++++++++++- .../number/std_number_min.proto.json | 14 +++++++++++++- .../number/std_number_modulo.proto.json | 14 +++++++++++++- .../number/std_number_multiply.proto.json | 14 +++++++++++++- .../number/std_number_negate.proto.json | 14 +++++++++++++- .../number/std_number_pi.proto.json | 14 +++++++++++++- .../number/std_number_random_number.proto.json | 14 +++++++++++++- .../number/std_number_root.proto.json | 14 +++++++++++++- .../number/std_number_round.proto.json | 14 +++++++++++++- .../number/std_number_round_down.proto.json | 14 +++++++++++++- .../number/std_number_round_up.proto.json | 14 +++++++++++++- .../number/std_number_sin.proto.json | 14 +++++++++++++- .../number/std_number_sinh.proto.json | 14 +++++++++++++- .../number/std_number_square.proto.json | 14 +++++++++++++- .../number/std_number_square_root.proto.json | 14 +++++++++++++- .../number/std_number_subtract.proto.json | 14 +++++++++++++- .../number/std_number_tan.proto.json | 14 +++++++++++++- .../object/std_object_contains_key.proto.json | 14 +++++++++++++- .../object/std_object_keys.proto.json | 14 +++++++++++++- .../object/std_object_set.proto.json | 14 +++++++++++++- .../object/std_object_size.proto.json | 14 +++++++++++++- .../text/std_text_append.proto.json | 14 +++++++++++++- .../text/std_text_as_bytes.proto.json | 14 +++++++++++++- .../text/std_text_at.proto.json | 14 +++++++++++++- .../text/std_text_byte_size.proto.json | 14 +++++++++++++- .../text/std_text_capitalize.proto.json | 14 +++++++++++++- .../text/std_text_chars.proto.json | 14 +++++++++++++- .../text/std_text_contains.proto.json | 14 +++++++++++++- .../text/std_text_decode.proto.json | 14 +++++++++++++- .../text/std_text_encode.proto.json | 14 +++++++++++++- .../text/std_text_ends_with.proto.json | 14 +++++++++++++- .../text/std_text_from_ascii.proto.json | 14 +++++++++++++- .../text/std_text_hex.proto.json | 14 +++++++++++++- .../text/std_text_index_of.proto.json | 14 +++++++++++++- .../text/std_text_insert.proto.json | 14 +++++++++++++- .../text/std_text_is_equal.proto.json | 14 +++++++++++++- .../text/std_text_length.proto.json | 14 +++++++++++++- .../text/std_text_lowercase.proto.json | 14 +++++++++++++- .../text/std_text_octal.proto.json | 14 +++++++++++++- .../text/std_text_prepend.proto.json | 14 +++++++++++++- .../text/std_text_remove.proto.json | 14 +++++++++++++- .../text/std_text_replace.proto.json | 14 +++++++++++++- .../text/std_text_replace_first.proto.json | 14 +++++++++++++- .../text/std_text_replace_last.proto.json | 14 +++++++++++++- .../text/std_text_reverse.proto.json | 14 +++++++++++++- .../text/std_text_split.proto.json | 14 +++++++++++++- .../text/std_text_start_with.proto.json | 14 +++++++++++++- .../text/std_text_swapcase.proto.json | 14 +++++++++++++- .../text/std_text_to_ascii.proto.json | 14 +++++++++++++- .../text/std_text_trim.proto.json | 14 +++++++++++++- .../text/std_text_uppercase.proto.json | 14 +++++++++++++- 110 files changed, 1428 insertions(+), 108 deletions(-) diff --git a/definitions/http/runtime_definition/control/http_control_respond.proto.json b/definitions/http/runtime_definition/control/http_control_respond.proto.json index 1e68c1a8..430c3e57 100644 --- a/definitions/http/runtime_definition/control/http_control_respond.proto.json +++ b/definitions/http/runtime_definition/control/http_control_respond.proto.json @@ -47,6 +47,18 @@ "content": "Processes an HTTP response and returns it to the requesting client. This function typically completes the HTTP request–response cycle by delivering the server’s final output, such as headers, status codes, and body content, back to the client." } ], + "alias": [ + { + "code": "en-US", + "content": "respond;control;http" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Apply respond to ${http_response}" + } + ], "throwsError": false, "genericKeys": [] -} \ No newline at end of file +} diff --git a/definitions/http/runtime_definition/request/http_request_create.proto.json b/definitions/http/runtime_definition/request/http_request_create.proto.json index 000a1ba4..627ca641 100644 --- a/definitions/http/runtime_definition/request/http_request_create.proto.json +++ b/definitions/http/runtime_definition/request/http_request_create.proto.json @@ -127,5 +127,17 @@ "content": "Generates an HTTP request object that can be sent to a server. The request includes an HTTP method, optional headers, a destination URL, and an optional request body." } ], + "alias": [ + { + "code": "en-US", + "content": "create;request;http" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Apply create to ${http_method}, ${headers}, ${url}, ${payload}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/http/runtime_definition/response/http_response_create.proto.json b/definitions/http/runtime_definition/response/http_response_create.proto.json index 07a88909..5f69c5de 100644 --- a/definitions/http/runtime_definition/response/http_response_create.proto.json +++ b/definitions/http/runtime_definition/response/http_response_create.proto.json @@ -102,5 +102,17 @@ "content": "Creates a complete HTTP response object to be returned from a server. The response includes a status code, headers, and an optional body containing the response content." } ], + "alias": [ + { + "code": "en-US", + "content": "create;response;http" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Apply create to ${http_status_code}, ${headers}, ${payload}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_at.proto.json b/definitions/standard/runtime_definition/array/std_array_at.proto.json index edca3f72..42e76cc4 100644 --- a/definitions/standard/runtime_definition/array/std_array_at.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_at.proto.json @@ -90,5 +90,17 @@ "content": "Returns the element located at the given zero-based index within the input array." } ], + "alias": [ + { + "code": "en-US", + "content": "at;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get element at ${index} of ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_concat.proto.json b/definitions/standard/runtime_definition/array/std_array_concat.proto.json index e4ef94e3..d16a646a 100644 --- a/definitions/standard/runtime_definition/array/std_array_concat.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_concat.proto.json @@ -116,5 +116,17 @@ "content": "Returns a new array containing all elements of the first array followed by all elements of the second array." } ], + "alias": [ + { + "code": "en-US", + "content": "concat;combine;join;append;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Combine ${first} with ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_filter.proto.json b/definitions/standard/runtime_definition/array/std_array_filter.proto.json index 6f1569a9..43e8af2a 100644 --- a/definitions/standard/runtime_definition/array/std_array_filter.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_filter.proto.json @@ -116,5 +116,17 @@ "content": "Returns a new array containing only the elements from the input array for which the predicate returns true." } ], + "alias": [ + { + "code": "en-US", + "content": "filter;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Filter out elements in ${array} not matching ${predicate}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_find.proto.json b/definitions/standard/runtime_definition/array/std_array_find.proto.json index d3aef839..bd06066b 100644 --- a/definitions/standard/runtime_definition/array/std_array_find.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_find.proto.json @@ -103,5 +103,17 @@ "content": "Returns the first element from the input array for which the predicate returns true. If no element matches, returns null or equivalent." } ], + "alias": [ + { + "code": "en-US", + "content": "find;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Find first element in ${array} matching ${predicate}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_find_index.proto.json b/definitions/standard/runtime_definition/array/std_array_find_index.proto.json index 8dc5032f..1fa79763 100644 --- a/definitions/standard/runtime_definition/array/std_array_find_index.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_find_index.proto.json @@ -103,5 +103,17 @@ "content": "Returns the zero-based index of the first element for which the predicate returns true. If no element matches, returns -1." } ], + "alias": [ + { + "code": "en-US", + "content": "find index;index of;position;array;list;collection;std;find;index" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Index of ${array} matching ${predicate}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_find_last.proto.json b/definitions/standard/runtime_definition/array/std_array_find_last.proto.json index 046cf9fa..40acf08d 100644 --- a/definitions/standard/runtime_definition/array/std_array_find_last.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_find_last.proto.json @@ -103,5 +103,17 @@ "content": "Returns the last element from the input array for which the predicate returns true. If no element matches, returns null or equivalent." } ], + "alias": [ + { + "code": "en-US", + "content": "find last;last index;last position;array;list;collection;std;find;last" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Last element of ${array} matching ${predicate}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_first.proto.json b/definitions/standard/runtime_definition/array/std_array_first.proto.json index dc566039..f3798751 100644 --- a/definitions/standard/runtime_definition/array/std_array_first.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_first.proto.json @@ -65,5 +65,17 @@ "content": "This runtime returns the first element in the given array, if any." } ], + "alias": [ + { + "code": "en-US", + "content": "first;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get first element in ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_flat.proto.json b/definitions/standard/runtime_definition/array/std_array_flat.proto.json index 7f806f18..5b481191 100644 --- a/definitions/standard/runtime_definition/array/std_array_flat.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_flat.proto.json @@ -91,5 +91,17 @@ "content": "Returns a new array by concatenating all sub-arrays of the input nested array into one flat array." } ], + "alias": [ + { + "code": "en-US", + "content": "flat;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Flatten ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_for_each.proto.json b/definitions/standard/runtime_definition/array/std_array_for_each.proto.json index b6608cd9..7890344b 100644 --- a/definitions/standard/runtime_definition/array/std_array_for_each.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_for_each.proto.json @@ -101,5 +101,17 @@ "content": "This runtime executes the given consumer function on each item in the array without returning a result." } ], + "alias": [ + { + "code": "en-US", + "content": "for_each;array;list;collection;std;for;each" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "For each in ${array} do ${consumer}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_index_of.proto.json b/definitions/standard/runtime_definition/array/std_array_index_of.proto.json index 0135673b..54f33996 100644 --- a/definitions/standard/runtime_definition/array/std_array_index_of.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_index_of.proto.json @@ -90,5 +90,17 @@ "content": "Returns the zero-based index of the first occurrence of a given item in the specified array. If the item is not found, it typically returns -1." } ], + "alias": [ + { + "code": "en-US", + "content": "index_of;array;list;collection;std;index;of" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get index of ${item} in ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_is_empty.proto.json b/definitions/standard/runtime_definition/array/std_array_is_empty.proto.json index 48bbf861..dfaf07d0 100644 --- a/definitions/standard/runtime_definition/array/std_array_is_empty.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_is_empty.proto.json @@ -65,5 +65,17 @@ "content": "Returns true if the array contains no elements, otherwise returns false." } ], + "alias": [ + { + "code": "en-US", + "content": "is_empty;array;list;collection;std;is;empty" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Check if ${array} is empty" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_join.proto.json b/definitions/standard/runtime_definition/array/std_array_join.proto.json index 7fcbbf95..8c5e0a0d 100644 --- a/definitions/standard/runtime_definition/array/std_array_join.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_join.proto.json @@ -73,7 +73,7 @@ "name": [ { "code": "en-US", - "content": "Filter and Join Text Array" + "content": "Join Text Array" } ], "description": [ @@ -88,5 +88,17 @@ "content": "Applies a filter operation on the input text array and returns a single concatenated string of filtered elements joined by the provided join text." } ], + "alias": [ + { + "code": "en-US", + "content": "join;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Joins ${array} using '${join_text}'" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_last.proto.json b/definitions/standard/runtime_definition/array/std_array_last.proto.json index 36797ab4..8f693371 100644 --- a/definitions/standard/runtime_definition/array/std_array_last.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_last.proto.json @@ -65,5 +65,17 @@ "content": "This runtime returns the last element in the given array, if any." } ], + "alias": [ + { + "code": "en-US", + "content": "last;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get last element of ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_map.proto.json b/definitions/standard/runtime_definition/array/std_array_map.proto.json index f7dcb6a4..37f5d03c 100644 --- a/definitions/standard/runtime_definition/array/std_array_map.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_map.proto.json @@ -126,5 +126,17 @@ "content": "This runtime applies the transform function to each element in the array, producing a new array of the results." } ], + "alias": [ + { + "code": "en-US", + "content": "map;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Apply ${transform} for each in ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_max.proto.json b/definitions/standard/runtime_definition/array/std_array_max.proto.json index a3c4a118..2b669702 100644 --- a/definitions/standard/runtime_definition/array/std_array_max.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_max.proto.json @@ -65,5 +65,17 @@ "content": "Returns the largest number contained in the provided array." } ], + "alias": [ + { + "code": "en-US", + "content": "max;maximum;largest;greatest;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Maximum of ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_min.proto.json b/definitions/standard/runtime_definition/array/std_array_min.proto.json index f4fcff8a..18c7eb75 100644 --- a/definitions/standard/runtime_definition/array/std_array_min.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_min.proto.json @@ -65,5 +65,17 @@ "content": "Returns the smallest number contained in the provided array." } ], + "alias": [ + { + "code": "en-US", + "content": "min;minimum;smallest;least;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Minimum of ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_pop.proto.json b/definitions/standard/runtime_definition/array/std_array_pop.proto.json index a5ab984f..bc0c517e 100644 --- a/definitions/standard/runtime_definition/array/std_array_pop.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_pop.proto.json @@ -65,5 +65,17 @@ "content": "Removes the last element from the specified array and returns it. The array is modified in place." } ], + "alias": [ + { + "code": "en-US", + "content": "pop;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Removes the last item of ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_push.proto.json b/definitions/standard/runtime_definition/array/std_array_push.proto.json index 40fb0627..303d1581 100644 --- a/definitions/standard/runtime_definition/array/std_array_push.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_push.proto.json @@ -90,5 +90,17 @@ "content": "Adds a new element to the end of the array and returns the new length of the array." } ], + "alias": [ + { + "code": "en-US", + "content": "push;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Push ${item} into ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_remove.proto.json b/definitions/standard/runtime_definition/array/std_array_remove.proto.json index 7b87576d..384ab744 100644 --- a/definitions/standard/runtime_definition/array/std_array_remove.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_remove.proto.json @@ -103,5 +103,17 @@ "content": "Removes the first matching item from the given array and returns the resulting array." } ], + "alias": [ + { + "code": "en-US", + "content": "remove;delete;strip;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Remove ${item} from ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_reverse.proto.json b/definitions/standard/runtime_definition/array/std_array_reverse.proto.json index 7162d0ad..4110daaa 100644 --- a/definitions/standard/runtime_definition/array/std_array_reverse.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_reverse.proto.json @@ -78,5 +78,17 @@ "content": "Returns a new array with the elements of the input array in reverse order." } ], + "alias": [ + { + "code": "en-US", + "content": "reverse;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Reverse ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_size.proto.json b/definitions/standard/runtime_definition/array/std_array_size.proto.json index 252185b6..0cc364c2 100644 --- a/definitions/standard/runtime_definition/array/std_array_size.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_size.proto.json @@ -65,5 +65,17 @@ "content": "This function returns the count of elements present in the given array." } ], + "alias": [ + { + "code": "en-US", + "content": "size;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Size of ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_sort.proto.json b/definitions/standard/runtime_definition/array/std_array_sort.proto.json index 108b74e6..60f18bac 100644 --- a/definitions/standard/runtime_definition/array/std_array_sort.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sort.proto.json @@ -116,5 +116,17 @@ "content": "Returns a new array with the elements sorted according to the comparator function provided." } ], + "alias": [ + { + "code": "en-US", + "content": "sort;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Sort ${array} using ${comparator}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json b/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json index 19c1637c..d57a39f7 100644 --- a/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json @@ -116,5 +116,17 @@ "content": "Returns a new array with the elements sorted in descending order according to the comparator function provided." } ], + "alias": [ + { + "code": "en-US", + "content": "sort_reverse;array;list;collection;std;sort;reverse" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Sort ${array} in reverse order using ${comparator}" + } + ], "deprecationMessage": [] } diff --git a/definitions/standard/runtime_definition/array/std_array_sum.proto.json b/definitions/standard/runtime_definition/array/std_array_sum.proto.json index dc0ef067..39e62d92 100644 --- a/definitions/standard/runtime_definition/array/std_array_sum.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sum.proto.json @@ -62,5 +62,17 @@ "content": "Adds up all numbers in the input array and returns their sum." } ], + "alias": [ + { + "code": "en-US", + "content": "sum;total;add all;array;list;collection;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Sum of ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json b/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json index 94c3d863..9b74c9ec 100644 --- a/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json @@ -78,5 +78,17 @@ "content": "Returns a new array containing only the unique elements from the input array. The original order may or may not be preserved depending on the implementation." } ], + "alias": [ + { + "code": "en-US", + "content": "to_unique;array;list;collection;std;to;unique" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Remove duplicates in ${array}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/boolean/std_boolean_as_number.proto.json b/definitions/standard/runtime_definition/boolean/std_boolean_as_number.proto.json index 8961c60c..6d5fbac5 100644 --- a/definitions/standard/runtime_definition/boolean/std_boolean_as_number.proto.json +++ b/definitions/standard/runtime_definition/boolean/std_boolean_as_number.proto.json @@ -50,5 +50,17 @@ "content": "Converts a boolean value to a number." } ], + "alias": [ + { + "code": "en-US", + "content": "to number;numeric;boolean;logic;std;as;number" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Convert ${value} to number" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/boolean/std_boolean_as_text.proto.json b/definitions/standard/runtime_definition/boolean/std_boolean_as_text.proto.json index 531ba880..8300663c 100644 --- a/definitions/standard/runtime_definition/boolean/std_boolean_as_text.proto.json +++ b/definitions/standard/runtime_definition/boolean/std_boolean_as_text.proto.json @@ -50,5 +50,17 @@ "content": "Converts a boolean value to a text string." } ], + "alias": [ + { + "code": "en-US", + "content": "to text;string;format number;boolean;logic;std;as;text" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Convert ${value} to text" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/boolean/std_boolean_from_number.proto.json b/definitions/standard/runtime_definition/boolean/std_boolean_from_number.proto.json index 4b81edcc..adb9ba13 100644 --- a/definitions/standard/runtime_definition/boolean/std_boolean_from_number.proto.json +++ b/definitions/standard/runtime_definition/boolean/std_boolean_from_number.proto.json @@ -50,5 +50,17 @@ "content": "Converts a number to a boolean value. Typically, 0 maps to false and non-zero maps to true." } ], + "alias": [ + { + "code": "en-US", + "content": "from number;to boolean;convert;boolean;logic;std;from;number" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Convert ${value} to boolean" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/boolean/std_boolean_from_text.proto.json b/definitions/standard/runtime_definition/boolean/std_boolean_from_text.proto.json index 49b4e113..1d6ee29e 100644 --- a/definitions/standard/runtime_definition/boolean/std_boolean_from_text.proto.json +++ b/definitions/standard/runtime_definition/boolean/std_boolean_from_text.proto.json @@ -50,5 +50,17 @@ "content": "Converts a text string to a boolean value. Recognizes 'true' and 'false' (case-insensitive)." } ], + "alias": [ + { + "code": "en-US", + "content": "from text;parse;convert;boolean;logic;std;from;text" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Convert ${value} to number" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/boolean/std_boolean_is_equal.proto.json b/definitions/standard/runtime_definition/boolean/std_boolean_is_equal.proto.json index 3dd756a0..1c8098f0 100644 --- a/definitions/standard/runtime_definition/boolean/std_boolean_is_equal.proto.json +++ b/definitions/standard/runtime_definition/boolean/std_boolean_is_equal.proto.json @@ -75,5 +75,17 @@ "content": "Compares two boolean values for equality. Returns true if they are the same, false otherwise." } ], + "alias": [ + { + "code": "en-US", + "content": "equal;equals;same;boolean;logic;std;is" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} equals ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/boolean/std_boolean_negate.proto.json b/definitions/standard/runtime_definition/boolean/std_boolean_negate.proto.json index b0fc7a22..2fcd02d7 100644 --- a/definitions/standard/runtime_definition/boolean/std_boolean_negate.proto.json +++ b/definitions/standard/runtime_definition/boolean/std_boolean_negate.proto.json @@ -50,5 +50,17 @@ "content": "Negates a boolean value." } ], + "alias": [ + { + "code": "en-US", + "content": "negate;negative;invert;opposite;boolean;logic;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Negate ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/control/std_control_if.proto.json b/definitions/standard/runtime_definition/control/std_control_if.proto.json index 1ef0a78d..a7216628 100644 --- a/definitions/standard/runtime_definition/control/std_control_if.proto.json +++ b/definitions/standard/runtime_definition/control/std_control_if.proto.json @@ -73,5 +73,17 @@ "content": "The 'If' runnable evaluates a boolean condition and, if it is true, executes the provided runnable. If the condition is false, execution continues without running the runnable. This behavior corresponds to a standard 'if' statement in programming languages." } ], + "alias": [ + { + "code": "en-US", + "content": "if;control;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "If ${condition} then do ${then_runnable}" + } + ], "deprecationMessage": [] } diff --git a/definitions/standard/runtime_definition/control/std_control_if_else.proto.json b/definitions/standard/runtime_definition/control/std_control_if_else.proto.json index 25b78fef..f44dc1c3 100644 --- a/definitions/standard/runtime_definition/control/std_control_if_else.proto.json +++ b/definitions/standard/runtime_definition/control/std_control_if_else.proto.json @@ -98,5 +98,17 @@ "content": "Evaluates a boolean condition. If true, executes the Then Runnable; otherwise, executes the Else Runnable. Mirrors a standard 'if/else' control structure in programming languages." } ], + "alias": [ + { + "code": "en-US", + "content": "if_else;control;std;if;else" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "If ${condition} do ${then_runnable} else ${else_runnable}" + } + ], "deprecationMessage": [] } diff --git a/definitions/standard/runtime_definition/control/std_control_return.proto.json b/definitions/standard/runtime_definition/control/std_control_return.proto.json index 2236b9b2..61f113e4 100644 --- a/definitions/standard/runtime_definition/control/std_control_return.proto.json +++ b/definitions/standard/runtime_definition/control/std_control_return.proto.json @@ -52,5 +52,17 @@ "content": "Ends the current context and returns the specified value to the upper scope. This node behaves like a standard 'return' statement in programming languages, stopping further execution within the current flow." } ], + "alias": [ + { + "code": "en-US", + "content": "return;control;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Return ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/control/std_control_stop.proto.json b/definitions/standard/runtime_definition/control/std_control_stop.proto.json index fbe66053..e04ce58e 100644 --- a/definitions/standard/runtime_definition/control/std_control_stop.proto.json +++ b/definitions/standard/runtime_definition/control/std_control_stop.proto.json @@ -22,5 +22,17 @@ "content": "Terminates the current execution context entirely, halting all ongoing and future iterations. Once invoked, no additional steps or loops within this context will be executed. This node behaves like a global stop or termination signal within the flow." } ], + "alias": [ + { + "code": "en-US", + "content": "stop;control;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Stop" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_abs.proto.json b/definitions/standard/runtime_definition/number/std_number_abs.proto.json index cf222e49..ce46e069 100644 --- a/definitions/standard/runtime_definition/number/std_number_abs.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_abs.proto.json @@ -50,5 +50,17 @@ "content": "Removes the sign from the input number, returning its non-negative value." } ], + "alias": [ + { + "code": "en-US", + "content": "absolute;abs;magnitude;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Absolute value of ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_add.proto.json b/definitions/standard/runtime_definition/number/std_number_add.proto.json index e6b64b9e..323a2816 100644 --- a/definitions/standard/runtime_definition/number/std_number_add.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_add.proto.json @@ -75,5 +75,17 @@ "content": "Adds two numbers together." } ], + "alias": [ + { + "code": "en-US", + "content": "add;plus;sum;total;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} + ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_arccos.proto.json b/definitions/standard/runtime_definition/number/std_number_arccos.proto.json index e1d8be95..9e1ac91f 100644 --- a/definitions/standard/runtime_definition/number/std_number_arccos.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_arccos.proto.json @@ -50,5 +50,17 @@ "content": "Computes the angle in radians whose cosine is the given number." } ], + "alias": [ + { + "code": "en-US", + "content": "arccos;acos;inverse cosine;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "arccos(${value})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_arcsin.proto.json b/definitions/standard/runtime_definition/number/std_number_arcsin.proto.json index 376f13d4..f21d2829 100644 --- a/definitions/standard/runtime_definition/number/std_number_arcsin.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_arcsin.proto.json @@ -50,5 +50,17 @@ "content": "Computes the angle in radians whose sine is the given number." } ], + "alias": [ + { + "code": "en-US", + "content": "arcsin;asin;inverse sine;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "arcsin(${value})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_arctan.proto.json b/definitions/standard/runtime_definition/number/std_number_arctan.proto.json index 4f895863..1be458e4 100644 --- a/definitions/standard/runtime_definition/number/std_number_arctan.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_arctan.proto.json @@ -50,5 +50,17 @@ "content": "Computes the angle in radians whose tangent is the given number." } ], + "alias": [ + { + "code": "en-US", + "content": "arctan;atan;inverse tangent;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "arctan(${value})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_as_text.proto.json b/definitions/standard/runtime_definition/number/std_number_as_text.proto.json index e6aaf8cc..df15a95b 100644 --- a/definitions/standard/runtime_definition/number/std_number_as_text.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_as_text.proto.json @@ -50,5 +50,17 @@ "content": "Transforms the given numeric value into a string format." } ], + "alias": [ + { + "code": "en-US", + "content": "to text;string;format number;number;math;std;as;text" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Convert ${number} to text" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_clamp.proto.json b/definitions/standard/runtime_definition/number/std_number_clamp.proto.json index c09c4181..ad864550 100644 --- a/definitions/standard/runtime_definition/number/std_number_clamp.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_clamp.proto.json @@ -100,5 +100,17 @@ "content": "Returns the given number clamped between the minimum and maximum bounds." } ], + "alias": [ + { + "code": "en-US", + "content": "clamp;limit;bound;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Clamp ${value} between ${min} and ${max}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_cos.proto.json b/definitions/standard/runtime_definition/number/std_number_cos.proto.json index 2f7e7e79..d18a0367 100644 --- a/definitions/standard/runtime_definition/number/std_number_cos.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_cos.proto.json @@ -50,5 +50,17 @@ "content": "Calculates the cosine value of the input angle measured in radians." } ], + "alias": [ + { + "code": "en-US", + "content": "cos;cosine;trigonometry;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "cos(${radians})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_cosh.proto.json b/definitions/standard/runtime_definition/number/std_number_cosh.proto.json index d4e98787..b035d25d 100644 --- a/definitions/standard/runtime_definition/number/std_number_cosh.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_cosh.proto.json @@ -50,5 +50,17 @@ "content": "Calculates the hyperbolic cosine (cosh) of the input value." } ], + "alias": [ + { + "code": "en-US", + "content": "cosh;hyperbolic cosine;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "cosh(${value})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_divide.proto.json b/definitions/standard/runtime_definition/number/std_number_divide.proto.json index 3eb1bbdf..4a68b4d7 100644 --- a/definitions/standard/runtime_definition/number/std_number_divide.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_divide.proto.json @@ -75,5 +75,17 @@ "content": "Returns the result of dividing the first numeric input (dividend) by the second (divisor)." } ], + "alias": [ + { + "code": "en-US", + "content": "divide;division;quotient;div;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} / ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_euler.proto.json b/definitions/standard/runtime_definition/number/std_number_euler.proto.json index 0cbf85a1..8f1ddd79 100644 --- a/definitions/standard/runtime_definition/number/std_number_euler.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_euler.proto.json @@ -24,5 +24,17 @@ "content": "Provides the constant value of Euler's number, approximately 2.71828, which is the base of the natural logarithm." } ], + "alias": [ + { + "code": "en-US", + "content": "euler;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Euler" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_exponential.proto.json b/definitions/standard/runtime_definition/number/std_number_exponential.proto.json index b027a4c8..95699400 100644 --- a/definitions/standard/runtime_definition/number/std_number_exponential.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_exponential.proto.json @@ -75,5 +75,17 @@ "content": "Computes the result of raising the base to the power specified by the exponent." } ], + "alias": [ + { + "code": "en-US", + "content": "exponential;exp;e power;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "e ^ ${base}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_from_text.proto.json b/definitions/standard/runtime_definition/number/std_number_from_text.proto.json index ccbca6d7..b6983dd4 100644 --- a/definitions/standard/runtime_definition/number/std_number_from_text.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_from_text.proto.json @@ -50,5 +50,17 @@ "content": "Attempts to parse the provided text input and return its numeric equivalent." } ], + "alias": [ + { + "code": "en-US", + "content": "from text;parse;convert;number;math;std;from;text" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Convert ${text} to number" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_infinity.proto.json b/definitions/standard/runtime_definition/number/std_number_infinity.proto.json index bbaf2233..37e74239 100644 --- a/definitions/standard/runtime_definition/number/std_number_infinity.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_infinity.proto.json @@ -24,5 +24,17 @@ "content": "Provides the representation of positive infinity, used to represent an unbounded value in computations." } ], + "alias": [ + { + "code": "en-US", + "content": "infinity;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Infinity" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_is_equal.proto.json b/definitions/standard/runtime_definition/number/std_number_is_equal.proto.json index 73a51a42..2f9a3b34 100644 --- a/definitions/standard/runtime_definition/number/std_number_is_equal.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_is_equal.proto.json @@ -75,5 +75,17 @@ "content": "Returns true if the first number is equal to the second number, otherwise false." } ], + "alias": [ + { + "code": "en-US", + "content": "equal;equals;same;number;math;std;is" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} == ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_is_greater.proto.json b/definitions/standard/runtime_definition/number/std_number_is_greater.proto.json index d556a9e7..c9c76fca 100644 --- a/definitions/standard/runtime_definition/number/std_number_is_greater.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_is_greater.proto.json @@ -75,5 +75,17 @@ "content": "Returns true if the first numeric input is greater than the second; otherwise, returns false." } ], + "alias": [ + { + "code": "en-US", + "content": "greater;larger;more;number;math;std;is" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} > ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_is_less.proto.json b/definitions/standard/runtime_definition/number/std_number_is_less.proto.json index 35367b01..3a601bc6 100644 --- a/definitions/standard/runtime_definition/number/std_number_is_less.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_is_less.proto.json @@ -75,5 +75,17 @@ "content": "Returns true if the first numeric input is less than the second; otherwise, returns false." } ], + "alias": [ + { + "code": "en-US", + "content": "less;smaller;fewer;number;math;std;is" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} < ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_is_positive.proto.json b/definitions/standard/runtime_definition/number/std_number_is_positive.proto.json index 716e4fb4..1998a8d5 100644 --- a/definitions/standard/runtime_definition/number/std_number_is_positive.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_is_positive.proto.json @@ -50,5 +50,17 @@ "content": "Evaluates the input number and returns true if it is positive (greater than zero), otherwise false." } ], + "alias": [ + { + "code": "en-US", + "content": "positive;greater than zero;number;math;std;is" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${value} > 0" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_is_zero.proto.json b/definitions/standard/runtime_definition/number/std_number_is_zero.proto.json index 06799160..84beda3b 100644 --- a/definitions/standard/runtime_definition/number/std_number_is_zero.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_is_zero.proto.json @@ -50,5 +50,17 @@ "content": "Returns true if the input number is zero; otherwise, returns false." } ], + "alias": [ + { + "code": "en-US", + "content": "zero;equals zero;number;math;std;is" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${value} == 0" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_ln.proto.json b/definitions/standard/runtime_definition/number/std_number_ln.proto.json index aa766721..938a11ac 100644 --- a/definitions/standard/runtime_definition/number/std_number_ln.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_ln.proto.json @@ -50,5 +50,17 @@ "content": "Returns the natural logarithm of the given value." } ], + "alias": [ + { + "code": "en-US", + "content": "natural log;ln;log e;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "ln(${value})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_log.proto.json b/definitions/standard/runtime_definition/number/std_number_log.proto.json index 9b55962c..8050e9c4 100644 --- a/definitions/standard/runtime_definition/number/std_number_log.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_log.proto.json @@ -75,5 +75,17 @@ "content": "Returns the logarithm of the given value using the specified base." } ], + "alias": [ + { + "code": "en-US", + "content": "log;logarithm;log base;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "log base ${base} of ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_max.proto.json b/definitions/standard/runtime_definition/number/std_number_max.proto.json index 3a3888e2..4a6ac35e 100644 --- a/definitions/standard/runtime_definition/number/std_number_max.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_max.proto.json @@ -75,5 +75,17 @@ "content": "Compares two numbers and returns the maximum value." } ], + "alias": [ + { + "code": "en-US", + "content": "max;maximum;largest;greatest;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Maximum of ${first} and ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_min.proto.json b/definitions/standard/runtime_definition/number/std_number_min.proto.json index 1e3c3bb5..df6e9792 100644 --- a/definitions/standard/runtime_definition/number/std_number_min.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_min.proto.json @@ -75,5 +75,17 @@ "content": "Compares two numbers and returns the minimum value." } ], + "alias": [ + { + "code": "en-US", + "content": "min;minimum;smallest;least;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Minimum of ${first} and ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_modulo.proto.json b/definitions/standard/runtime_definition/number/std_number_modulo.proto.json index db358c75..451b5447 100644 --- a/definitions/standard/runtime_definition/number/std_number_modulo.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_modulo.proto.json @@ -75,5 +75,17 @@ "content": "Computes the modulus (remainder) of dividing the first numeric input by the second." } ], + "alias": [ + { + "code": "en-US", + "content": "modulo;mod;remainder;modulus;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} % ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_multiply.proto.json b/definitions/standard/runtime_definition/number/std_number_multiply.proto.json index 2f25da75..fa74b1fc 100644 --- a/definitions/standard/runtime_definition/number/std_number_multiply.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_multiply.proto.json @@ -75,5 +75,17 @@ "content": "Takes two numeric inputs and returns their product." } ], + "alias": [ + { + "code": "en-US", + "content": "multiply;times;product;mul;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} * ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_negate.proto.json b/definitions/standard/runtime_definition/number/std_number_negate.proto.json index c130a3db..db27aab0 100644 --- a/definitions/standard/runtime_definition/number/std_number_negate.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_negate.proto.json @@ -50,5 +50,17 @@ "content": "Calculates the additive inverse of the given number." } ], + "alias": [ + { + "code": "en-US", + "content": "negate;negative;invert;opposite;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Negate ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_pi.proto.json b/definitions/standard/runtime_definition/number/std_number_pi.proto.json index 95f5edea..7ec3b81b 100644 --- a/definitions/standard/runtime_definition/number/std_number_pi.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_pi.proto.json @@ -24,5 +24,17 @@ "content": "Provides the constant value of pi, approximately 3.14159, used in many mathematical calculations." } ], + "alias": [ + { + "code": "en-US", + "content": "pi;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get pi" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_random_number.proto.json b/definitions/standard/runtime_definition/number/std_number_random_number.proto.json index 98fa68a0..574fa3e2 100644 --- a/definitions/standard/runtime_definition/number/std_number_random_number.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_random_number.proto.json @@ -75,5 +75,17 @@ "content": "Returns a randomly generated number within the given range, inclusive of both minimum and maximum." } ], + "alias": [ + { + "code": "en-US", + "content": "random;rand;random number;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Random number between ${min} and ${max}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_root.proto.json b/definitions/standard/runtime_definition/number/std_number_root.proto.json index 88745540..b2467e48 100644 --- a/definitions/standard/runtime_definition/number/std_number_root.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_root.proto.json @@ -75,5 +75,17 @@ "content": "Calculates the nth root of the input number, where n is specified by the root exponent." } ], + "alias": [ + { + "code": "en-US", + "content": "root;nth root;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${root_exponent} root of ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_round.proto.json b/definitions/standard/runtime_definition/number/std_number_round.proto.json index 6a3ecfb3..d2e3f749 100644 --- a/definitions/standard/runtime_definition/number/std_number_round.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_round.proto.json @@ -75,5 +75,17 @@ "content": "Performs standard rounding on the given value, rounding up or down depending on the fractional component." } ], + "alias": [ + { + "code": "en-US", + "content": "round;nearest;approximate;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Round ${value} with ${decimals} decimal places" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_round_down.proto.json b/definitions/standard/runtime_definition/number/std_number_round_down.proto.json index 655ece39..7aa98938 100644 --- a/definitions/standard/runtime_definition/number/std_number_round_down.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_round_down.proto.json @@ -75,5 +75,17 @@ "content": "Performs rounding on the given value, always rounding down to the nearest value at the given decimal precision." } ], + "alias": [ + { + "code": "en-US", + "content": "round down;floor;number;math;std;round;down" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Round down ${value} with ${decimals} decimal places" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_round_up.proto.json b/definitions/standard/runtime_definition/number/std_number_round_up.proto.json index 358041ff..0fc31bc0 100644 --- a/definitions/standard/runtime_definition/number/std_number_round_up.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_round_up.proto.json @@ -75,5 +75,17 @@ "content": "Performs rounding on the given value, always rounding up to the nearest value at the given decimal precision." } ], + "alias": [ + { + "code": "en-US", + "content": "round up;ceil;ceiling;number;math;std;round;up" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Round up ${value} with ${decimals} decimal places" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_sin.proto.json b/definitions/standard/runtime_definition/number/std_number_sin.proto.json index 14412fe7..5919df2d 100644 --- a/definitions/standard/runtime_definition/number/std_number_sin.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_sin.proto.json @@ -75,5 +75,17 @@ "content": "Returns a pseudo-random number between the given minimum and maximum values." } ], + "alias": [ + { + "code": "en-US", + "content": "sin;sine;trigonometry;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "sin(${min})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_sinh.proto.json b/definitions/standard/runtime_definition/number/std_number_sinh.proto.json index d6dcaf37..c74b0fcf 100644 --- a/definitions/standard/runtime_definition/number/std_number_sinh.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_sinh.proto.json @@ -50,5 +50,17 @@ "content": "Calculates the hyperbolic sine (sinh) of the input value." } ], + "alias": [ + { + "code": "en-US", + "content": "sinh;hyperbolic sine;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "sinh(${value})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_square.proto.json b/definitions/standard/runtime_definition/number/std_number_square.proto.json index 80107363..ca928a39 100644 --- a/definitions/standard/runtime_definition/number/std_number_square.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_square.proto.json @@ -50,5 +50,17 @@ "content": "Calculates the value multiplied by itself, effectively raising it to the power of 2." } ], + "alias": [ + { + "code": "en-US", + "content": "square;squared;power two;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${value} squared" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_square_root.proto.json b/definitions/standard/runtime_definition/number/std_number_square_root.proto.json index cb00954b..09dd129a 100644 --- a/definitions/standard/runtime_definition/number/std_number_square_root.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_square_root.proto.json @@ -50,5 +50,17 @@ "content": "Calculates the positive square root of the input number." } ], + "alias": [ + { + "code": "en-US", + "content": "square root;sqrt;root;number;math;std;square" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Square root of ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_subtract.proto.json b/definitions/standard/runtime_definition/number/std_number_subtract.proto.json index 0a22bac5..00ee8f0a 100644 --- a/definitions/standard/runtime_definition/number/std_number_subtract.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_subtract.proto.json @@ -75,5 +75,17 @@ "content": "Returns the result of subtracting the second numeric input from the first." } ], + "alias": [ + { + "code": "en-US", + "content": "subtract;minus;difference;sub;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} - ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/number/std_number_tan.proto.json b/definitions/standard/runtime_definition/number/std_number_tan.proto.json index b330ca92..a16634a3 100644 --- a/definitions/standard/runtime_definition/number/std_number_tan.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_tan.proto.json @@ -50,5 +50,17 @@ "content": "Calculates the tangent value of the input angle measured in radians." } ], + "alias": [ + { + "code": "en-US", + "content": "tan;tangent;trigonometry;number;math;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "tan(${radians})" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/object/std_object_contains_key.proto.json b/definitions/standard/runtime_definition/object/std_object_contains_key.proto.json index 9f80cd1c..02564263 100644 --- a/definitions/standard/runtime_definition/object/std_object_contains_key.proto.json +++ b/definitions/standard/runtime_definition/object/std_object_contains_key.proto.json @@ -75,5 +75,17 @@ "content": "Returns true if the given key is a property of the object; otherwise, returns false." } ], + "alias": [ + { + "code": "en-US", + "content": "contains_key;object;std;contains;key" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Checks if ${object} contains ${key}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/object/std_object_keys.proto.json b/definitions/standard/runtime_definition/object/std_object_keys.proto.json index c23593c5..418a5b9f 100644 --- a/definitions/standard/runtime_definition/object/std_object_keys.proto.json +++ b/definitions/standard/runtime_definition/object/std_object_keys.proto.json @@ -63,5 +63,17 @@ "content": "Returns an array containing all enumerable property names (keys) of the specified object." } ], + "alias": [ + { + "code": "en-US", + "content": "keys;object;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get all keys of ${object}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/object/std_object_set.proto.json b/definitions/standard/runtime_definition/object/std_object_set.proto.json index a466d5a1..73f58361 100644 --- a/definitions/standard/runtime_definition/object/std_object_set.proto.json +++ b/definitions/standard/runtime_definition/object/std_object_set.proto.json @@ -102,5 +102,17 @@ "content": "Returns a new object with the specified key set to the given value." } ], + "alias": [ + { + "code": "en-US", + "content": "set;object;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Will set ${key} to ${value} inside of ${object}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/object/std_object_size.proto.json b/definitions/standard/runtime_definition/object/std_object_size.proto.json index 635a4edd..3102402a 100644 --- a/definitions/standard/runtime_definition/object/std_object_size.proto.json +++ b/definitions/standard/runtime_definition/object/std_object_size.proto.json @@ -50,5 +50,17 @@ "content": "Returns an integer count of all enumerable property keys in the specified object." } ], + "alias": [ + { + "code": "en-US", + "content": "size;object;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get size of ${object}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_append.proto.json b/definitions/standard/runtime_definition/text/std_text_append.proto.json index 603ac170..d87e3f7c 100644 --- a/definitions/standard/runtime_definition/text/std_text_append.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_append.proto.json @@ -75,5 +75,17 @@ "content": "Returns a new text string consisting of the original text followed by the specified suffix." } ], + "alias": [ + { + "code": "en-US", + "content": "append;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Append ${value} with ${suffix}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json b/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json index c73b9b0b..095a9297 100644 --- a/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json @@ -63,5 +63,17 @@ "content": "Returns an array of bytes representing the UTF-8 encoding of the given text." } ], + "alias": [ + { + "code": "en-US", + "content": "as_bytes;text;string;std;as;bytes" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "As Bytes ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_at.proto.json b/definitions/standard/runtime_definition/text/std_text_at.proto.json index a4f4a20b..0922db23 100644 --- a/definitions/standard/runtime_definition/text/std_text_at.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_at.proto.json @@ -75,5 +75,17 @@ "content": "Retrieves a single character from the input text based on the provided zero-based index." } ], + "alias": [ + { + "code": "en-US", + "content": "at;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get character of ${value} at ${index}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_byte_size.proto.json b/definitions/standard/runtime_definition/text/std_text_byte_size.proto.json index 42580e6c..789a842c 100644 --- a/definitions/standard/runtime_definition/text/std_text_byte_size.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_byte_size.proto.json @@ -50,5 +50,17 @@ "content": "Computes the size in bytes of the provided text string, typically by counting UTF-8 encoded bytes." } ], + "alias": [ + { + "code": "en-US", + "content": "byte_size;text;string;std;byte;size" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Byte-Size of ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_capitalize.proto.json b/definitions/standard/runtime_definition/text/std_text_capitalize.proto.json index 26bb21ae..4c186856 100644 --- a/definitions/standard/runtime_definition/text/std_text_capitalize.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_capitalize.proto.json @@ -50,5 +50,17 @@ "content": "Returns a new text string with the first letter capitalized." } ], + "alias": [ + { + "code": "en-US", + "content": "capitalize;title case;upper first;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Capitalize ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_chars.proto.json b/definitions/standard/runtime_definition/text/std_text_chars.proto.json index 66425427..6120d16c 100644 --- a/definitions/standard/runtime_definition/text/std_text_chars.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_chars.proto.json @@ -63,5 +63,17 @@ "content": "Creates an array where each element is a single character from the original text." } ], + "alias": [ + { + "code": "en-US", + "content": "characters;letters;split;text;string;std;chars" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Turns ${value} into a list of characters" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_contains.proto.json b/definitions/standard/runtime_definition/text/std_text_contains.proto.json index bb2a7f70..9d4127c2 100644 --- a/definitions/standard/runtime_definition/text/std_text_contains.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_contains.proto.json @@ -75,5 +75,17 @@ "content": "Returns true if the substring is found anywhere in the main text; otherwise, returns false." } ], + "alias": [ + { + "code": "en-US", + "content": "contains;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Check if ${value} contains ${substring}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_decode.proto.json b/definitions/standard/runtime_definition/text/std_text_decode.proto.json index 5fea0806..567901fd 100644 --- a/definitions/standard/runtime_definition/text/std_text_decode.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_decode.proto.json @@ -75,5 +75,17 @@ "content": "Decodes the input text from the specified encoding format." } ], + "alias": [ + { + "code": "en-US", + "content": "decode;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Decode ${value} using ${encoding}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_encode.proto.json b/definitions/standard/runtime_definition/text/std_text_encode.proto.json index 606f101e..ca7234af 100644 --- a/definitions/standard/runtime_definition/text/std_text_encode.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_encode.proto.json @@ -75,5 +75,17 @@ "content": "Transforms the given text string into a representation encoded by the specified encoding scheme." } ], + "alias": [ + { + "code": "en-US", + "content": "encode;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Encode ${value} to ${encoding}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_ends_with.proto.json b/definitions/standard/runtime_definition/text/std_text_ends_with.proto.json index a6f72d2d..4195f81c 100644 --- a/definitions/standard/runtime_definition/text/std_text_ends_with.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_ends_with.proto.json @@ -75,5 +75,17 @@ "content": "Returns true if the input text ends with the given suffix; otherwise, returns false." } ], + "alias": [ + { + "code": "en-US", + "content": "ends_with;text;string;std;ends;with" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Check if ${value} ends with ${suffix}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json b/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json index 2f317354..0a983552 100644 --- a/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json @@ -63,5 +63,17 @@ "content": "Takes an array of numbers where each number is an ASCII code, and returns the string they represent." } ], + "alias": [ + { + "code": "en-US", + "content": "from_ascii;text;string;std;from;ascii" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "From ${value} to Text" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_hex.proto.json b/definitions/standard/runtime_definition/text/std_text_hex.proto.json index d233d71f..1b9c6947 100644 --- a/definitions/standard/runtime_definition/text/std_text_hex.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_hex.proto.json @@ -50,5 +50,17 @@ "content": "Returns a string containing the hexadecimal values corresponding to each character of the input text." } ], + "alias": [ + { + "code": "en-US", + "content": "hex;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${value} to Hexadecimal" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_index_of.proto.json b/definitions/standard/runtime_definition/text/std_text_index_of.proto.json index aa7be9ed..095b671b 100644 --- a/definitions/standard/runtime_definition/text/std_text_index_of.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_index_of.proto.json @@ -75,5 +75,17 @@ "content": "Returns the zero-based index of the first occurrence of the substring in the text. Returns -1 if the substring is not found." } ], + "alias": [ + { + "code": "en-US", + "content": "index_of;text;string;std;index;of" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Get position of ${substring} inside ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_insert.proto.json b/definitions/standard/runtime_definition/text/std_text_insert.proto.json index 14f154d1..45bec755 100644 --- a/definitions/standard/runtime_definition/text/std_text_insert.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_insert.proto.json @@ -100,5 +100,17 @@ "content": "Returns a new string where the provided text is inserted at the zero-based position index within the original text." } ], + "alias": [ + { + "code": "en-US", + "content": "insert;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Insert ${value} at ${position} into ${text}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_is_equal.proto.json b/definitions/standard/runtime_definition/text/std_text_is_equal.proto.json index e8edad26..b44a2bc1 100644 --- a/definitions/standard/runtime_definition/text/std_text_is_equal.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_is_equal.proto.json @@ -75,5 +75,17 @@ "content": "Determines if the two given text inputs are exactly the same, returning true if equal, false otherwise." } ], + "alias": [ + { + "code": "en-US", + "content": "equal;equals;same;text;string;std;is" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${first} equals ${second}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_length.proto.json b/definitions/standard/runtime_definition/text/std_text_length.proto.json index c07bc676..ddc3624d 100644 --- a/definitions/standard/runtime_definition/text/std_text_length.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_length.proto.json @@ -50,5 +50,17 @@ "content": "Computes the length of the input string in terms of characters." } ], + "alias": [ + { + "code": "en-US", + "content": "length;size;characters;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Length of ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_lowercase.proto.json b/definitions/standard/runtime_definition/text/std_text_lowercase.proto.json index b9718232..7f27c4b2 100644 --- a/definitions/standard/runtime_definition/text/std_text_lowercase.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_lowercase.proto.json @@ -50,5 +50,17 @@ "content": "Returns a new text string with all characters converted to lowercase." } ], + "alias": [ + { + "code": "en-US", + "content": "lowercase;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${value} to Lowercase" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_octal.proto.json b/definitions/standard/runtime_definition/text/std_text_octal.proto.json index d08926a6..9b8a7a8b 100644 --- a/definitions/standard/runtime_definition/text/std_text_octal.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_octal.proto.json @@ -50,5 +50,17 @@ "content": "Returns a string containing the octal values corresponding to each character of the input text." } ], + "alias": [ + { + "code": "en-US", + "content": "octal;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${value} to Octal" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_prepend.proto.json b/definitions/standard/runtime_definition/text/std_text_prepend.proto.json index 7fc90cf1..6bef3fb3 100644 --- a/definitions/standard/runtime_definition/text/std_text_prepend.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_prepend.proto.json @@ -75,5 +75,17 @@ "content": "Returns a new text string consisting of the specified prefix followed by the original text." } ], + "alias": [ + { + "code": "en-US", + "content": "prepend;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Prepend ${value} with ${prefix}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_remove.proto.json b/definitions/standard/runtime_definition/text/std_text_remove.proto.json index 24f5ed18..4bdd470e 100644 --- a/definitions/standard/runtime_definition/text/std_text_remove.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_remove.proto.json @@ -100,5 +100,17 @@ "content": "Returns a new string with characters removed from start up to but not including end." } ], + "alias": [ + { + "code": "en-US", + "content": "remove;delete;strip;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Remove ${value} from ${start}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_replace.proto.json b/definitions/standard/runtime_definition/text/std_text_replace.proto.json index 99197289..feb92532 100644 --- a/definitions/standard/runtime_definition/text/std_text_replace.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_replace.proto.json @@ -100,5 +100,17 @@ "content": "Returns a new string where every instance of the old substring is replaced by the new substring." } ], + "alias": [ + { + "code": "en-US", + "content": "replace;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "In ${value} replace ${old} with ${new}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_replace_first.proto.json b/definitions/standard/runtime_definition/text/std_text_replace_first.proto.json index 39ed3cea..8ef4c5e1 100644 --- a/definitions/standard/runtime_definition/text/std_text_replace_first.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_replace_first.proto.json @@ -100,5 +100,17 @@ "content": "Returns a new string where only the first instance of the old substring is replaced by the new substring." } ], + "alias": [ + { + "code": "en-US", + "content": "replace_first;text;string;std;replace;first" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "In ${value} replace first ${old} with ${new}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_replace_last.proto.json b/definitions/standard/runtime_definition/text/std_text_replace_last.proto.json index b8335362..376ee010 100644 --- a/definitions/standard/runtime_definition/text/std_text_replace_last.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_replace_last.proto.json @@ -100,5 +100,17 @@ "content": "Returns a new string where only the last instance of the old substring is replaced by the new substring." } ], + "alias": [ + { + "code": "en-US", + "content": "replace_last;text;string;std;replace;last" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "In ${value} replace the last ${old} with ${new}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_reverse.proto.json b/definitions/standard/runtime_definition/text/std_text_reverse.proto.json index 06eb7a19..d7f8062f 100644 --- a/definitions/standard/runtime_definition/text/std_text_reverse.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_reverse.proto.json @@ -50,5 +50,17 @@ "content": "Returns a new string with the characters of the input text in reverse order." } ], + "alias": [ + { + "code": "en-US", + "content": "reverse;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Reverse ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_split.proto.json b/definitions/standard/runtime_definition/text/std_text_split.proto.json index 6827be2c..6c9d105f 100644 --- a/definitions/standard/runtime_definition/text/std_text_split.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_split.proto.json @@ -88,5 +88,17 @@ "content": "Returns an array of substrings obtained by splitting the input text at each occurrence of the delimiter." } ], + "alias": [ + { + "code": "en-US", + "content": "split;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Splits ${value} on '${delimiter}'" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_start_with.proto.json b/definitions/standard/runtime_definition/text/std_text_start_with.proto.json index 8ec5aca3..ae3875b9 100644 --- a/definitions/standard/runtime_definition/text/std_text_start_with.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_start_with.proto.json @@ -75,5 +75,17 @@ "content": "Returns true if the input text begins with the given prefix; otherwise, returns false." } ], + "alias": [ + { + "code": "en-US", + "content": "text;string;std;start;with" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Check if ${value} starts with ${prefix}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_swapcase.proto.json b/definitions/standard/runtime_definition/text/std_text_swapcase.proto.json index 53ca6c7d..14b2ba69 100644 --- a/definitions/standard/runtime_definition/text/std_text_swapcase.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_swapcase.proto.json @@ -50,5 +50,17 @@ "content": "Returns a new text string with the case of each character inverted." } ], + "alias": [ + { + "code": "en-US", + "content": "swapcase;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Swapcase of ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json b/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json index 38ac46e8..e9500a09 100644 --- a/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json @@ -63,5 +63,17 @@ "content": "Returns an array of numbers where each number represents the ASCII code of the corresponding character in the input text." } ], + "alias": [ + { + "code": "en-US", + "content": "to_ascii;text;string;std;to;ascii" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "${value} To Ascii" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_trim.proto.json b/definitions/standard/runtime_definition/text/std_text_trim.proto.json index 6b9ce181..1a137af8 100644 --- a/definitions/standard/runtime_definition/text/std_text_trim.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_trim.proto.json @@ -50,5 +50,17 @@ "content": "Returns a new string with all leading and trailing whitespace characters removed from the input text." } ], + "alias": [ + { + "code": "en-US", + "content": "trim;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Trim ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} diff --git a/definitions/standard/runtime_definition/text/std_text_uppercase.proto.json b/definitions/standard/runtime_definition/text/std_text_uppercase.proto.json index c285eea2..419b5f17 100644 --- a/definitions/standard/runtime_definition/text/std_text_uppercase.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_uppercase.proto.json @@ -50,5 +50,17 @@ "content": "Returns a new text string with all characters converted to uppercase." } ], + "alias": [ + { + "code": "en-US", + "content": "uppercase;text;string;std" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Uppercase ${value}" + } + ], "deprecationMessage": [] -} \ No newline at end of file +} From a10eead39f68a6b99a2d1075043c2a435fdc7eb7 Mon Sep 17 00:00:00 2001 From: Raphael Date: Thu, 20 Nov 2025 15:23:35 +0100 Subject: [PATCH 05/14] ref: renamed all references of array to list --- .../array/http_header_map.proto.json | 2 +- .../{array.proto.json => list.proto.json} | 4 +-- .../array/std_array_at.proto.json | 22 ++++++++-------- .../array/std_array_concat.proto.json | 26 +++++++++---------- .../array/std_array_filter.proto.json | 24 ++++++++--------- .../array/std_array_find.proto.json | 22 ++++++++-------- .../array/std_array_find_index.proto.json | 20 +++++++------- .../array/std_array_find_last.proto.json | 22 ++++++++-------- .../array/std_array_first.proto.json | 20 +++++++------- .../array/std_array_flat.proto.json | 24 ++++++++--------- .../array/std_array_for_each.proto.json | 22 ++++++++-------- .../array/std_array_index_of.proto.json | 22 ++++++++-------- .../array/std_array_is_empty.proto.json | 20 +++++++------- .../array/std_array_join.proto.json | 22 ++++++++-------- .../array/std_array_last.proto.json | 20 +++++++------- .../array/std_array_map.proto.json | 26 +++++++++---------- .../array/std_array_max.proto.json | 18 ++++++------- .../array/std_array_min.proto.json | 18 ++++++------- .../array/std_array_pop.proto.json | 20 +++++++------- .../array/std_array_push.proto.json | 24 ++++++++--------- .../array/std_array_remove.proto.json | 26 +++++++++---------- .../array/std_array_reverse.proto.json | 22 ++++++++-------- .../array/std_array_size.proto.json | 20 +++++++------- .../array/std_array_sort.proto.json | 22 ++++++++-------- .../array/std_array_sort_reverse.proto.json | 22 ++++++++-------- .../array/std_array_sum.proto.json | 18 ++++++------- .../array/std_array_to_unique.proto.json | 20 +++++++------- .../object/std_object_keys.proto.json | 8 +++--- .../text/std_text_as_bytes.proto.json | 8 +++--- .../text/std_text_chars.proto.json | 8 +++--- .../text/std_text_from_ascii.proto.json | 10 +++---- .../text/std_text_split.proto.json | 6 ++--- .../text/std_text_to_ascii.proto.json | 4 +-- 33 files changed, 296 insertions(+), 296 deletions(-) rename definitions/standard/data_type/array/{array.proto.json => list.proto.json} (87%) diff --git a/definitions/http/data_type/array/http_header_map.proto.json b/definitions/http/data_type/array/http_header_map.proto.json index 9f4c9e41..cb694fb8 100644 --- a/definitions/http/data_type/array/http_header_map.proto.json +++ b/definitions/http/data_type/array/http_header_map.proto.json @@ -24,7 +24,7 @@ "parentType": { "parentType": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ diff --git a/definitions/standard/data_type/array/array.proto.json b/definitions/standard/data_type/array/list.proto.json similarity index 87% rename from definitions/standard/data_type/array/array.proto.json rename to definitions/standard/data_type/array/list.proto.json index 1bdca048..96d33c35 100644 --- a/definitions/standard/data_type/array/array.proto.json +++ b/definitions/standard/data_type/array/list.proto.json @@ -1,10 +1,10 @@ { "variant": "ARRAY", - "identifier": "ARRAY", + "identifier": "LIST", "name": [ { "code": "en-US", - "content": "Generic Array" + "content": "Generic List" } ], "alias": [ diff --git a/definitions/standard/runtime_definition/array/std_array_at.proto.json b/definitions/standard/runtime_definition/array/std_array_at.proto.json index 42e76cc4..773624e5 100644 --- a/definitions/standard/runtime_definition/array/std_array_at.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_at.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::at", + "runtimeName": "std::list::at", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "List", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array from which to retrieve an element." + "content": "The list from which to retrieve an element." } ], "documentation": [ { "code": "en-US", - "content": "An array containing elements of any type. The element at the specified index will be returned." + "content": "An list containing elements of any type. The element at the specified index will be returned." } ] }, @@ -60,7 +60,7 @@ "documentation": [ { "code": "en-US", - "content": "Specifies the position of the element in the array to return. Must be within the bounds of the array." + "content": "Specifies the position of the element in the list to return. Must be within the bounds of the list." } ] } @@ -75,19 +75,19 @@ "name": [ { "code": "en-US", - "content": "Get Array Element" + "content": "Get List Element" } ], "description": [ { "code": "en-US", - "content": "Retrieves the element at a specified index from an array." + "content": "Retrieves the element at a specified index from an list." } ], "documentation": [ { "code": "en-US", - "content": "Returns the element located at the given zero-based index within the input array." + "content": "Returns the element located at the given zero-based index within the input list." } ], "alias": [ @@ -99,7 +99,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Get element at ${index} of ${array}" + "content": "Get element at ${index} of ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_concat.proto.json b/definitions/standard/runtime_definition/array/std_array_concat.proto.json index d16a646a..f377f9bc 100644 --- a/definitions/standard/runtime_definition/array/std_array_concat.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_concat.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::concat", + "runtimeName": "std::list::concat", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -23,26 +23,26 @@ "name": [ { "code": "en-US", - "content": "First Array" + "content": "First List" } ], "description": [ { "code": "en-US", - "content": "The first array to concatenate." + "content": "The first list to concatenate." } ], "documentation": [ { "code": "en-US", - "content": "The first input array whose elements will appear at the beginning of the resulting array." + "content": "The first input list whose elements will appear at the beginning of the resulting list." } ] }, { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -61,26 +61,26 @@ "name": [ { "code": "en-US", - "content": "Second Array" + "content": "Second List" } ], "description": [ { "code": "en-US", - "content": "The second array to concatenate." + "content": "The second list to concatenate." } ], "documentation": [ { "code": "en-US", - "content": "The second input array whose elements will be appended after the elements of the first array." + "content": "The second input list whose elements will be appended after the elements of the first list." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -101,19 +101,19 @@ "name": [ { "code": "en-US", - "content": "Concatenate Arrays" + "content": "Concatenate Lists" } ], "description": [ { "code": "en-US", - "content": "Concatenates two arrays into a single array." + "content": "Concatenates two lists into a single list." } ], "documentation": [ { "code": "en-US", - "content": "Returns a new array containing all elements of the first array followed by all elements of the second array." + "content": "Returns a new list containing all elements of the first list followed by all elements of the second list." } ], "alias": [ diff --git a/definitions/standard/runtime_definition/array/std_array_filter.proto.json b/definitions/standard/runtime_definition/array/std_array_filter.proto.json index 43e8af2a..b9b26b1f 100644 --- a/definitions/standard/runtime_definition/array/std_array_filter.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_filter.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::filter", + "runtimeName": "std::list::filter", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array to be filtered." + "content": "The list to be filtered." } ], "documentation": [ { "code": "en-US", - "content": "The original array from which elements will be selected based on the predicate." + "content": "The original list from which elements will be selected based on the predicate." } ] }, @@ -73,14 +73,14 @@ "documentation": [ { "code": "en-US", - "content": "A function that takes an element of the array and returns a boolean indicating whether the element should be included in the output array." + "content": "A function that takes an element of the list and returns a boolean indicating whether the element should be included in the output list." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -101,19 +101,19 @@ "name": [ { "code": "en-US", - "content": "Filter Array" + "content": "Filter List" } ], "description": [ { "code": "en-US", - "content": "Filters elements of an array based on a predicate." + "content": "Filters elements of an list based on a predicate." } ], "documentation": [ { "code": "en-US", - "content": "Returns a new array containing only the elements from the input array for which the predicate returns true." + "content": "Returns a new list containing only the elements from the input list for which the predicate returns true." } ], "alias": [ @@ -125,7 +125,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Filter out elements in ${array} not matching ${predicate}" + "content": "Filter out elements in ${list} not matching ${predicate}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_find.proto.json b/definitions/standard/runtime_definition/array/std_array_find.proto.json index bd06066b..818cd640 100644 --- a/definitions/standard/runtime_definition/array/std_array_find.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_find.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::find", + "runtimeName": "std::list::find", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array to search through." + "content": "The list to search through." } ], "documentation": [ { "code": "en-US", - "content": "The array in which an element satisfying the predicate will be searched." + "content": "The list in which an element satisfying the predicate will be searched." } ] }, @@ -73,7 +73,7 @@ "documentation": [ { "code": "en-US", - "content": "A function that takes an element of the array and returns a boolean indicating if the element matches the search criteria." + "content": "A function that takes an element of the list and returns a boolean indicating if the element matches the search criteria." } ] } @@ -88,19 +88,19 @@ "name": [ { "code": "en-US", - "content": "Find Element in Array" + "content": "Find Element in List" } ], "description": [ { "code": "en-US", - "content": "Finds the first element in the array that satisfies the predicate." + "content": "Finds the first element in the list that satisfies the predicate." } ], "documentation": [ { "code": "en-US", - "content": "Returns the first element from the input array for which the predicate returns true. If no element matches, returns null or equivalent." + "content": "Returns the first element from the input list for which the predicate returns true. If no element matches, returns null or equivalent." } ], "alias": [ @@ -112,7 +112,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Find first element in ${array} matching ${predicate}" + "content": "Find first element in ${list} matching ${predicate}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_find_index.proto.json b/definitions/standard/runtime_definition/array/std_array_find_index.proto.json index 1fa79763..44d36a5d 100644 --- a/definitions/standard/runtime_definition/array/std_array_find_index.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_find_index.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::find_index", + "runtimeName": "std::list::find_index", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array to search through." + "content": "The list to search through." } ], "documentation": [ { "code": "en-US", - "content": "The array in which to find the index of an element that satisfies the predicate." + "content": "The list in which to find the index of an element that satisfies the predicate." } ] }, @@ -73,7 +73,7 @@ "documentation": [ { "code": "en-US", - "content": "A function that takes an element of the array and returns a boolean indicating if the element satisfies the search criteria." + "content": "A function that takes an element of the list and returns a boolean indicating if the element satisfies the search criteria." } ] } @@ -88,13 +88,13 @@ "name": [ { "code": "en-US", - "content": "Find Index in Array" + "content": "Find Index in List" } ], "description": [ { "code": "en-US", - "content": "Finds the index of the first element in the array that satisfies the predicate." + "content": "Finds the index of the first element in the list that satisfies the predicate." } ], "documentation": [ @@ -112,7 +112,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Index of ${array} matching ${predicate}" + "content": "Index of ${list} matching ${predicate}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_find_last.proto.json b/definitions/standard/runtime_definition/array/std_array_find_last.proto.json index 40acf08d..25b721db 100644 --- a/definitions/standard/runtime_definition/array/std_array_find_last.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_find_last.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::find_last", + "runtimeName": "std::list::find_last", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array to search through." + "content": "The list to search through." } ], "documentation": [ { "code": "en-US", - "content": "The array in which an element satisfying the predicate will be searched." + "content": "The list in which an element satisfying the predicate will be searched." } ] }, @@ -73,7 +73,7 @@ "documentation": [ { "code": "en-US", - "content": "A function that takes an element of the array and returns a boolean indicating if the element matches the search criteria." + "content": "A function that takes an element of the list and returns a boolean indicating if the element matches the search criteria." } ] } @@ -88,19 +88,19 @@ "name": [ { "code": "en-US", - "content": "Find Last Element in Array" + "content": "Find Last Element in List" } ], "description": [ { "code": "en-US", - "content": "Finds the last element in the array that satisfies the predicate." + "content": "Finds the last element in the list that satisfies the predicate." } ], "documentation": [ { "code": "en-US", - "content": "Returns the last element from the input array for which the predicate returns true. If no element matches, returns null or equivalent." + "content": "Returns the last element from the input list for which the predicate returns true. If no element matches, returns null or equivalent." } ], "alias": [ @@ -112,7 +112,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Last element of ${array} matching ${predicate}" + "content": "Last element of ${list} matching ${predicate}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_first.proto.json b/definitions/standard/runtime_definition/array/std_array_first.proto.json index f3798751..93fef75d 100644 --- a/definitions/standard/runtime_definition/array/std_array_first.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_first.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::first", + "runtimeName": "std::list::first", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array from which to retrieve the first element." + "content": "The list from which to retrieve the first element." } ], "documentation": [ { "code": "en-US", - "content": "Returns the first element of the provided array. If the array is empty, behavior depends on the implementation." + "content": "Returns the first element of the provided list. If the list is empty, behavior depends on the implementation." } ] } @@ -50,19 +50,19 @@ "name": [ { "code": "en-US", - "content": "First Element of Array" + "content": "First Element of List" } ], "description": [ { "code": "en-US", - "content": "Retrieves the first element from the array." + "content": "Retrieves the first element from the list." } ], "documentation": [ { "code": "en-US", - "content": "This runtime returns the first element in the given array, if any." + "content": "This runtime returns the first element in the given list, if any." } ], "alias": [ @@ -74,7 +74,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Get first element in ${array}" + "content": "Get first element in ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_flat.proto.json b/definitions/standard/runtime_definition/array/std_array_flat.proto.json index 5b481191..8d52344b 100644 --- a/definitions/standard/runtime_definition/array/std_array_flat.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_flat.proto.json @@ -1,16 +1,16 @@ { - "runtimeName": "std::array::flat", + "runtimeName": "std::list::flat", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -31,31 +31,31 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Nested Array" + "content": "Nested List" } ], "description": [ { "code": "en-US", - "content": "The nested array to be flattened." + "content": "The nested list to be flattened." } ], "documentation": [ { "code": "en-US", - "content": "An array containing sub-arrays that will be flattened into a single-level array." + "content": "An list containing sub-lists that will be flattened into a single-level list." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -76,19 +76,19 @@ "name": [ { "code": "en-US", - "content": "Flatten Array" + "content": "Flatten List" } ], "description": [ { "code": "en-US", - "content": "Flattens a nested array into a single-level array." + "content": "Flattens a nested list into a single-level list." } ], "documentation": [ { "code": "en-US", - "content": "Returns a new array by concatenating all sub-arrays of the input nested array into one flat array." + "content": "Returns a new list by concatenating all sub-lists of the input nested list into one flat list." } ], "alias": [ @@ -100,7 +100,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Flatten ${array}" + "content": "Flatten ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_for_each.proto.json b/definitions/standard/runtime_definition/array/std_array_for_each.proto.json index 7890344b..f1e69327 100644 --- a/definitions/standard/runtime_definition/array/std_array_for_each.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_for_each.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::for_each", + "runtimeName": "std::list::for_each", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array of elements to iterate over." + "content": "The list of elements to iterate over." } ], "documentation": [ { "code": "en-US", - "content": "Each element of this array will be passed to the provided consumer function for processing." + "content": "Each element of this list will be passed to the provided consumer function for processing." } ] }, @@ -67,13 +67,13 @@ "description": [ { "code": "en-US", - "content": "A function that consumes each element of the array." + "content": "A function that consumes each element of the list." } ], "documentation": [ { "code": "en-US", - "content": "This function is invoked once for each element in the array. It is not expected to return a value." + "content": "This function is invoked once for each element in the list. It is not expected to return a value." } ] } @@ -92,13 +92,13 @@ "description": [ { "code": "en-US", - "content": "Executes a consumer function for each element in the array." + "content": "Executes a consumer function for each element in the list." } ], "documentation": [ { "code": "en-US", - "content": "This runtime executes the given consumer function on each item in the array without returning a result." + "content": "This runtime executes the given consumer function on each item in the list without returning a result." } ], "alias": [ @@ -110,7 +110,7 @@ "displayMessage": [ { "code": "en-US", - "content": "For each in ${array} do ${consumer}" + "content": "For each in ${list} do ${consumer}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_index_of.proto.json b/definitions/standard/runtime_definition/array/std_array_index_of.proto.json index 54f33996..fd4a6546 100644 --- a/definitions/standard/runtime_definition/array/std_array_index_of.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_index_of.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::index_of", + "runtimeName": "std::list::index_of", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The array to search within." + "content": "The list to search within." } ], "documentation": [ { "code": "en-US", - "content": "An array of elements in which the specified item will be searched for to determine its index." + "content": "An list of elements in which the specified item will be searched for to determine its index." } ] }, @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "The item whose index is to be found in the array." + "content": "The item whose index is to be found in the list." } ], "documentation": [ { "code": "en-US", - "content": "The item for which the function searches in the array and returns the index of its first occurrence." + "content": "The item for which the function searches in the list and returns the index of its first occurrence." } ] } @@ -81,13 +81,13 @@ "description": [ { "code": "en-US", - "content": "Finds the index of the first occurrence of the specified item in the array." + "content": "Finds the index of the first occurrence of the specified item in the list." } ], "documentation": [ { "code": "en-US", - "content": "Returns the zero-based index of the first occurrence of a given item in the specified array. If the item is not found, it typically returns -1." + "content": "Returns the zero-based index of the first occurrence of a given item in the specified list. If the item is not found, it typically returns -1." } ], "alias": [ @@ -99,7 +99,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Get index of ${item} in ${array}" + "content": "Get index of ${item} in ${list }" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_is_empty.proto.json b/definitions/standard/runtime_definition/array/std_array_is_empty.proto.json index dfaf07d0..a27aa6cf 100644 --- a/definitions/standard/runtime_definition/array/std_array_is_empty.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_is_empty.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::is_empty", + "runtimeName": "std::list::is_empty", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The array to check for emptiness." + "content": "The list to check for emptiness." } ], "documentation": [ { "code": "en-US", - "content": "The array whose length will be evaluated to determine if it contains any elements." + "content": "The list whose length will be evaluated to determine if it contains any elements." } ] } @@ -50,19 +50,19 @@ "name": [ { "code": "en-US", - "content": "Is Array Empty" + "content": "Is List Empty" } ], "description": [ { "code": "en-US", - "content": "Checks if the array has no elements." + "content": "Checks if the list has no elements." } ], "documentation": [ { "code": "en-US", - "content": "Returns true if the array contains no elements, otherwise returns false." + "content": "Returns true if the list contains no elements, otherwise returns false." } ], "alias": [ @@ -74,7 +74,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Check if ${array} is empty" + "content": "Check if ${list} is empty" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_join.proto.json b/definitions/standard/runtime_definition/array/std_array_join.proto.json index 8c5e0a0d..5adfc294 100644 --- a/definitions/standard/runtime_definition/array/std_array_join.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_join.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::join", + "runtimeName": "std::list::join", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Text Array" + "content": "Text List" } ], "description": [ { "code": "en-US", - "content": "An array of text elements to be filtered." + "content": "An list of text elements to be filtered." } ], "documentation": [ { "code": "en-US", - "content": "Input array containing text elements for filtering." + "content": "Input list containing text elements for filtering." } ] }, @@ -60,7 +60,7 @@ "documentation": [ { "code": "en-US", - "content": "The delimiter or text that will be used to join the filtered array elements into a single string." + "content": "The delimiter or text that will be used to join the filtered list elements into a single string." } ] } @@ -73,19 +73,19 @@ "name": [ { "code": "en-US", - "content": "Join Text Array" + "content": "Join Text List" } ], "description": [ { "code": "en-US", - "content": "Filters the input text array and joins the filtered elements into a single string separated by the specified join text." + "content": "Filters the input text list and joins the filtered elements into a single string separated by the specified join text." } ], "documentation": [ { "code": "en-US", - "content": "Applies a filter operation on the input text array and returns a single concatenated string of filtered elements joined by the provided join text." + "content": "Applies a filter operation on the input text list and returns a single concatenated string of filtered elements joined by the provided join text." } ], "alias": [ @@ -97,7 +97,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Joins ${array} using '${join_text}'" + "content": "Joins ${list} using '${join_text}'" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_last.proto.json b/definitions/standard/runtime_definition/array/std_array_last.proto.json index 8f693371..b352d840 100644 --- a/definitions/standard/runtime_definition/array/std_array_last.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_last.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::last", + "runtimeName": "std::list::last", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array from which to retrieve the last element." + "content": "The list from which to retrieve the last element." } ], "documentation": [ { "code": "en-US", - "content": "Returns the last element of the provided array. If the array is empty, behavior depends on the implementation." + "content": "Returns the last element of the provided list. If the list is empty, behavior depends on the implementation." } ] } @@ -50,19 +50,19 @@ "name": [ { "code": "en-US", - "content": "Last Element of Array" + "content": "Last Element of List" } ], "description": [ { "code": "en-US", - "content": "Retrieves the last element from the array." + "content": "Retrieves the last element from the list." } ], "documentation": [ { "code": "en-US", - "content": "This runtime returns the last element in the given array, if any." + "content": "This runtime returns the last element in the given list, if any." } ], "alias": [ @@ -74,7 +74,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Get last element of ${array}" + "content": "Get last element of ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_map.proto.json b/definitions/standard/runtime_definition/array/std_array_map.proto.json index 37f5d03c..421c9bf4 100644 --- a/definitions/standard/runtime_definition/array/std_array_map.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_map.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::map", + "runtimeName": "std::list::map", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LISt", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Input Array" + "content": "Input List" } ], "description": [ { "code": "en-US", - "content": "The array to be transformed." + "content": "The list to be transformed." } ], "documentation": [ { "code": "en-US", - "content": "Each element of this array will be passed through the transform function." + "content": "Each element of this list will be passed through the transform function." } ] }, @@ -76,20 +76,20 @@ "description": [ { "code": "en-US", - "content": "A function that transforms each item in the array." + "content": "A function that transforms each item in the list." } ], "documentation": [ { "code": "en-US", - "content": "The transform function is applied to every element of the array to produce a new array." + "content": "The transform function is applied to every element of the list to produce a new list." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -111,19 +111,19 @@ "name": [ { "code": "en-US", - "content": "Map Array" + "content": "Map List" } ], "description": [ { "code": "en-US", - "content": "Transforms each element in the array using the provided function." + "content": "Transforms each element in the list using the provided function." } ], "documentation": [ { "code": "en-US", - "content": "This runtime applies the transform function to each element in the array, producing a new array of the results." + "content": "This runtime applies the transform function to each element in the list, producing a new list of the results." } ], "alias": [ @@ -135,7 +135,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Apply ${transform} for each in ${array}" + "content": "Apply ${transform} for each in ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_max.proto.json b/definitions/standard/runtime_definition/array/std_array_max.proto.json index 2b669702..4aca276a 100644 --- a/definitions/standard/runtime_definition/array/std_array_max.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_max.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::max", + "runtimeName": "std::list::max", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Number Array" + "content": "Number List" } ], "description": [ { "code": "en-US", - "content": "An array of numbers to find the maximum value from." + "content": "An list of numbers to find the maximum value from." } ], "documentation": [ { "code": "en-US", - "content": "Returns the largest number in the given array of numbers." + "content": "Returns the largest number in the given list of numbers." } ] } @@ -56,13 +56,13 @@ "description": [ { "code": "en-US", - "content": "Finds the maximum value in a numeric array." + "content": "Finds the maximum value in a numeric list." } ], "documentation": [ { "code": "en-US", - "content": "Returns the largest number contained in the provided array." + "content": "Returns the largest number contained in the provided list." } ], "alias": [ @@ -74,7 +74,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Maximum of ${array}" + "content": "Maximum of ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_min.proto.json b/definitions/standard/runtime_definition/array/std_array_min.proto.json index 18c7eb75..6af5cb98 100644 --- a/definitions/standard/runtime_definition/array/std_array_min.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_min.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::min", + "runtimeName": "std::list::min", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Number Array" + "content": "Number List" } ], "description": [ { "code": "en-US", - "content": "An array of numbers to find the minimum value from." + "content": "An list of numbers to find the minimum value from." } ], "documentation": [ { "code": "en-US", - "content": "Returns the smallest number in the given array of numbers." + "content": "Returns the smallest number in the given list of numbers." } ] } @@ -56,13 +56,13 @@ "description": [ { "code": "en-US", - "content": "Finds the minimum value in a numeric array." + "content": "Finds the minimum value in a numeric list." } ], "documentation": [ { "code": "en-US", - "content": "Returns the smallest number contained in the provided array." + "content": "Returns the smallest number contained in the provided list." } ], "alias": [ @@ -74,7 +74,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Minimum of ${array}" + "content": "Minimum of ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_pop.proto.json b/definitions/standard/runtime_definition/array/std_array_pop.proto.json index bc0c517e..69924d36 100644 --- a/definitions/standard/runtime_definition/array/std_array_pop.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_pop.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::pop", + "runtimeName": "std::list::pop", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The array to remove the last item from." + "content": "The list to remove the last item from." } ], "documentation": [ { "code": "en-US", - "content": "This is the array from which the last element will be removed and returned." + "content": "This is the list from which the last element will be removed and returned." } ] } @@ -50,19 +50,19 @@ "name": [ { "code": "en-US", - "content": "Pop from Array" + "content": "Pop from List" } ], "description": [ { "code": "en-US", - "content": "Removes and returns the last item from the array." + "content": "Removes and returns the last item from the list." } ], "documentation": [ { "code": "en-US", - "content": "Removes the last element from the specified array and returns it. The array is modified in place." + "content": "Removes the last element from the specified list and returns it. The list is modified in place." } ], "alias": [ @@ -74,7 +74,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Removes the last item of ${array}" + "content": "Removes the last item of ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_push.proto.json b/definitions/standard/runtime_definition/array/std_array_push.proto.json index 303d1581..311d6bbb 100644 --- a/definitions/standard/runtime_definition/array/std_array_push.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_push.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::push", + "runtimeName": "std::list::push", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The array to which an item will be added." + "content": "The list to which an item will be added." } ], "documentation": [ { "code": "en-US", - "content": "The array that the new item will be appended to." + "content": "The list that the new item will be appended to." } ] }, @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "The item to add to the array." + "content": "The item to add to the list." } ], "documentation": [ { "code": "en-US", - "content": "The value to be added at the end of the array." + "content": "The value to be added at the end of the list." } ] } @@ -75,19 +75,19 @@ "name": [ { "code": "en-US", - "content": "Push to Array" + "content": "Push to List" } ], "description": [ { "code": "en-US", - "content": "Appends an item to the end of an array." + "content": "Appends an item to the end of an list." } ], "documentation": [ { "code": "en-US", - "content": "Adds a new element to the end of the array and returns the new length of the array." + "content": "Adds a new element to the end of the list and returns the new length of the list." } ], "alias": [ @@ -99,7 +99,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Push ${item} into ${array}" + "content": "Push ${item} into ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_remove.proto.json b/definitions/standard/runtime_definition/array/std_array_remove.proto.json index 384ab744..7edae221 100644 --- a/definitions/standard/runtime_definition/array/std_array_remove.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_remove.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::remove", + "runtimeName": "std::list::remove", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The array from which the item will be removed." + "content": "The list from which the item will be removed." } ], "documentation": [ { "code": "en-US", - "content": "An array to process by removing the first occurrence of the specified item." + "content": "An list to process by removing the first occurrence of the specified item." } ] }, @@ -54,20 +54,20 @@ "description": [ { "code": "en-US", - "content": "The item to remove from the array." + "content": "The item to remove from the list." } ], "documentation": [ { "code": "en-US", - "content": "The value to search for and remove from the array. Only the first matching item is removed." + "content": "The value to search for and remove from the list. Only the first matching item is removed." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -88,19 +88,19 @@ "name": [ { "code": "en-US", - "content": "Remove from Array" + "content": "Remove from List" } ], "description": [ { "code": "en-US", - "content": "Removes the first occurrence of the specified item from the array." + "content": "Removes the first occurrence of the specified item from the list." } ], "documentation": [ { "code": "en-US", - "content": "Removes the first matching item from the given array and returns the resulting array." + "content": "Removes the first matching item from the given list and returns the resulting list." } ], "alias": [ @@ -112,7 +112,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Remove ${item} from ${array}" + "content": "Remove ${item} from ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_reverse.proto.json b/definitions/standard/runtime_definition/array/std_array_reverse.proto.json index 4110daaa..9b3b1e63 100644 --- a/definitions/standard/runtime_definition/array/std_array_reverse.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_reverse.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::reverse", + "runtimeName": "std::list::reverse", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,31 +18,31 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The input array to be reversed." + "content": "The input list to be reversed." } ], "documentation": [ { "code": "en-US", - "content": "An array of elements whose order will be reversed." + "content": "An list of elements whose order will be reversed." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -63,19 +63,19 @@ "name": [ { "code": "en-US", - "content": "Reverse Array" + "content": "Reverse List" } ], "description": [ { "code": "en-US", - "content": "Reverses the order of elements in the array." + "content": "Reverses the order of elements in the list." } ], "documentation": [ { "code": "en-US", - "content": "Returns a new array with the elements of the input array in reverse order." + "content": "Returns a new list with the elements of the input list in reverse order." } ], "alias": [ @@ -87,7 +87,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Reverse ${array}" + "content": "Reverse ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_size.proto.json b/definitions/standard/runtime_definition/array/std_array_size.proto.json index 0cc364c2..a4ac955b 100644 --- a/definitions/standard/runtime_definition/array/std_array_size.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_size.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::size", + "runtimeName": "std::list::size", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The array whose number of elements is to be returned." + "content": "The list whose number of elements is to be returned." } ], "documentation": [ { "code": "en-US", - "content": "Specifies the array for which the total number of elements will be calculated and returned." + "content": "Specifies the list for which the total number of elements will be calculated and returned." } ] } @@ -50,19 +50,19 @@ "name": [ { "code": "en-US", - "content": "Array Size" + "content": "List Size" } ], "description": [ { "code": "en-US", - "content": "Returns the number of elements in the array." + "content": "Returns the number of elements in the list." } ], "documentation": [ { "code": "en-US", - "content": "This function returns the count of elements present in the given array." + "content": "This function returns the count of elements present in the given list." } ], "alias": [ @@ -74,7 +74,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Size of ${array}" + "content": "Size of ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_sort.proto.json b/definitions/standard/runtime_definition/array/std_array_sort.proto.json index 60f18bac..0686f846 100644 --- a/definitions/standard/runtime_definition/array/std_array_sort.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sort.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::sort", + "runtimeName": "std::list::sort", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The input array to be sorted." + "content": "The input list to be sorted." } ], "documentation": [ { "code": "en-US", - "content": "An array of elements that will be sorted using the provided comparator function." + "content": "An list of elements that will be sorted using the provided comparator function." } ] }, @@ -80,7 +80,7 @@ ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -101,19 +101,19 @@ "name": [ { "code": "en-US", - "content": "Sort Array" + "content": "Sort List" } ], "description": [ { "code": "en-US", - "content": "Sorts the elements of the array using the specified comparator." + "content": "Sorts the elements of the list using the specified comparator." } ], "documentation": [ { "code": "en-US", - "content": "Returns a new array with the elements sorted according to the comparator function provided." + "content": "Returns a new list with the elements sorted according to the comparator function provided." } ], "alias": [ @@ -125,7 +125,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Sort ${array} using ${comparator}" + "content": "Sort ${list} using ${comparator}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json b/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json index d57a39f7..92e83ea9 100644 --- a/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::sort_reverse", + "runtimeName": "std::list::sort_reverse", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,24 +18,24 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The input array to be sorted in reverse order." + "content": "The input list to be sorted in reverse order." } ], "documentation": [ { "code": "en-US", - "content": "An array of elements that will be sorted in descending order using the provided comparator." + "content": "An list of elements that will be sorted in descending order using the provided comparator." } ] }, @@ -80,7 +80,7 @@ ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -101,19 +101,19 @@ "name": [ { "code": "en-US", - "content": "Sort Array in Reverse" + "content": "Sort List in Reverse" } ], "description": [ { "code": "en-US", - "content": "Sorts the elements of the array in reverse order using the specified comparator." + "content": "Sorts the elements of the list in reverse order using the specified comparator." } ], "documentation": [ { "code": "en-US", - "content": "Returns a new array with the elements sorted in descending order according to the comparator function provided." + "content": "Returns a new list with the elements sorted in descending order according to the comparator function provided." } ], "alias": [ @@ -125,7 +125,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Sort ${array} in reverse order using ${comparator}" + "content": "Sort ${list} in reverse order using ${comparator}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_sum.proto.json b/definitions/standard/runtime_definition/array/std_array_sum.proto.json index 39e62d92..6cbda643 100644 --- a/definitions/standard/runtime_definition/array/std_array_sum.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sum.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::sum", + "runtimeName": "std::list::sum", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,23 +18,23 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "name": [ { "code": "en-US", - "content": "Number Array" + "content": "Number List" } ], "description": [ { "code": "en-US", - "content": "An array of numbers to be summed." + "content": "An list of numbers to be summed." } ], "documentation": [ { "code": "en-US", - "content": "Calculates the sum of all numbers in the given array." + "content": "Calculates the sum of all numbers in the given list." } ] } @@ -53,13 +53,13 @@ "description": [ { "code": "en-US", - "content": "Returns the total sum of the elements in the numeric array." + "content": "Returns the total sum of the elements in the numeric list." } ], "documentation": [ { "code": "en-US", - "content": "Adds up all numbers in the input array and returns their sum." + "content": "Adds up all numbers in the input list and returns their sum." } ], "alias": [ @@ -71,7 +71,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Sum of ${array}" + "content": "Sum of ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json b/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json index 9b74c9ec..99a685d0 100644 --- a/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json @@ -1,10 +1,10 @@ { - "runtimeName": "std::array::to_unique", + "runtimeName": "std::list::to_unique", "runtimeParameterDefinitions": [ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -18,31 +18,31 @@ ] } }, - "runtimeName": "array", + "runtimeName": "list", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Array" + "content": "List" } ], "description": [ { "code": "en-US", - "content": "The input array from which duplicates will be removed." + "content": "The input list from which duplicates will be removed." } ], "documentation": [ { "code": "en-US", - "content": "An array of elements that may contain duplicates. This function will remove any duplicate items and return a new array with unique values only." + "content": "An list of elements that may contain duplicates. This function will remove any duplicate items and return a new list with unique values only." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -69,13 +69,13 @@ "description": [ { "code": "en-US", - "content": "Removes duplicate elements from the input array." + "content": "Removes duplicate elements from the input list." } ], "documentation": [ { "code": "en-US", - "content": "Returns a new array containing only the unique elements from the input array. The original order may or may not be preserved depending on the implementation." + "content": "Returns a new list containing only the unique elements from the input list. The original order may or may not be preserved depending on the implementation." } ], "alias": [ @@ -87,7 +87,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Remove duplicates in ${array}" + "content": "Remove duplicates in ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/object/std_object_keys.proto.json b/definitions/standard/runtime_definition/object/std_object_keys.proto.json index 418a5b9f..519633f4 100644 --- a/definitions/standard/runtime_definition/object/std_object_keys.proto.json +++ b/definitions/standard/runtime_definition/object/std_object_keys.proto.json @@ -22,14 +22,14 @@ "documentation": [ { "code": "en-US", - "content": "Returns an array of all the keys (property names) of the given object." + "content": "Returns an list of all the keys (property names) of the given object." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "Retrieves all the keys from the given object as an array of text values." + "content": "Retrieves all the keys from the given object as an list of text values." } ], "documentation": [ { "code": "en-US", - "content": "Returns an array containing all enumerable property names (keys) of the specified object." + "content": "Returns an list containing all enumerable property names (keys) of the specified object." } ], "alias": [ diff --git a/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json b/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json index 095a9297..272d2e61 100644 --- a/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json @@ -22,14 +22,14 @@ "documentation": [ { "code": "en-US", - "content": "Converts the input text string into an array of byte values." + "content": "Converts the input text string into an list of byte values." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "Converts a text string into an array of byte values." + "content": "Converts a text string into an list of byte values." } ], "documentation": [ { "code": "en-US", - "content": "Returns an array of bytes representing the UTF-8 encoding of the given text." + "content": "Returns an list of bytes representing the UTF-8 encoding of the given text." } ], "alias": [ diff --git a/definitions/standard/runtime_definition/text/std_text_chars.proto.json b/definitions/standard/runtime_definition/text/std_text_chars.proto.json index 6120d16c..e8d31adf 100644 --- a/definitions/standard/runtime_definition/text/std_text_chars.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_chars.proto.json @@ -22,14 +22,14 @@ "documentation": [ { "code": "en-US", - "content": "Splits the input text string into an array of its constituent characters." + "content": "Splits the input text string into an list of its constituent characters." } ] } ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "Returns an array containing each character from the given text string." + "content": "Returns an list containing each character from the given text string." } ], "documentation": [ { "code": "en-US", - "content": "Creates an array where each element is a single character from the original text." + "content": "Creates an list where each element is a single character from the original text." } ], "alias": [ diff --git a/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json b/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json index 0a983552..2e0e9657 100644 --- a/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json @@ -4,7 +4,7 @@ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -29,13 +29,13 @@ "description": [ { "code": "en-US", - "content": "Array of ASCII numeric codes representing characters." + "content": "List of ASCII numeric codes representing characters." } ], "documentation": [ { "code": "en-US", - "content": "Array of ASCII numeric codes representing characters." + "content": "List of ASCII numeric codes representing characters." } ] } @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "Converts an array of ASCII codes back into the corresponding text string." + "content": "Converts an list of ASCII codes back into the corresponding text string." } ], "documentation": [ { "code": "en-US", - "content": "Takes an array of numbers where each number is an ASCII code, and returns the string they represent." + "content": "Takes an list of numbers where each number is an ASCII code, and returns the string they represent." } ], "alias": [ diff --git a/definitions/standard/runtime_definition/text/std_text_split.proto.json b/definitions/standard/runtime_definition/text/std_text_split.proto.json index 6c9d105f..a84e4971 100644 --- a/definitions/standard/runtime_definition/text/std_text_split.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_split.proto.json @@ -54,7 +54,7 @@ ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -79,13 +79,13 @@ "description": [ { "code": "en-US", - "content": "Splits the input text into an array of substrings based on the specified delimiter." + "content": "Splits the input text into an list of substrings based on the specified delimiter." } ], "documentation": [ { "code": "en-US", - "content": "Returns an array of substrings obtained by splitting the input text at each occurrence of the delimiter." + "content": "Returns an list of substrings obtained by splitting the input text at each occurrence of the delimiter." } ], "alias": [ diff --git a/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json b/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json index e9500a09..90a40168 100644 --- a/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json @@ -29,7 +29,7 @@ ], "returnTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "ARRAY", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ @@ -60,7 +60,7 @@ "documentation": [ { "code": "en-US", - "content": "Returns an array of numbers where each number represents the ASCII code of the corresponding character in the input text." + "content": "Returns an list of numbers where each number represents the ASCII code of the corresponding character in the input text." } ], "alias": [ From 10f170c044e09b3b0095af5fb02a36a32f0cb53a Mon Sep 17 00:00:00 2001 From: Raphael Date: Thu, 20 Nov 2025 18:01:42 +0100 Subject: [PATCH 06/14] ref: removed typos --- .../data_type/object/http_response.proto.json | 2 +- definitions/http/flow_type/http.proto.json | 2 +- .../data_type/node/transform.proto.json | 2 +- .../array/std_array_at.proto.json | 2 +- .../array/std_array_index_of.proto.json | 2 +- .../array/std_array_map.proto.json | 2 +- .../boolean/std_boolean_from_text.proto.json | 2 +- .../number/std_number_sin.proto.json | 39 ++++--------------- 8 files changed, 14 insertions(+), 39 deletions(-) diff --git a/definitions/http/data_type/object/http_response.proto.json b/definitions/http/data_type/object/http_response.proto.json index eef1c749..e606fe7a 100644 --- a/definitions/http/data_type/object/http_response.proto.json +++ b/definitions/http/data_type/object/http_response.proto.json @@ -16,7 +16,7 @@ "displayMessage": [ { "code": "en-US", - "content": "HTTP Respons" + "content": "HTTP Response" } ], "rules": [ diff --git a/definitions/http/flow_type/http.proto.json b/definitions/http/flow_type/http.proto.json index 35d3a40b..41952115 100644 --- a/definitions/http/flow_type/http.proto.json +++ b/definitions/http/flow_type/http.proto.json @@ -80,7 +80,7 @@ "displayMessage": [ { "code": "en-US", - "content": "On ${method} request to §{route}" + "content": "On ${method} request to ${route}" } ], "alias": [ diff --git a/definitions/standard/data_type/node/transform.proto.json b/definitions/standard/data_type/node/transform.proto.json index 42cf0a5c..27fbc0d7 100644 --- a/definitions/standard/data_type/node/transform.proto.json +++ b/definitions/standard/data_type/node/transform.proto.json @@ -16,7 +16,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Transform §{I} to ${R}" + "content": "Transform ${I} to ${R}" } ], "rules": [ diff --git a/definitions/standard/runtime_definition/array/std_array_at.proto.json b/definitions/standard/runtime_definition/array/std_array_at.proto.json index 773624e5..9aaa0908 100644 --- a/definitions/standard/runtime_definition/array/std_array_at.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_at.proto.json @@ -4,7 +4,7 @@ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "List", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ diff --git a/definitions/standard/runtime_definition/array/std_array_index_of.proto.json b/definitions/standard/runtime_definition/array/std_array_index_of.proto.json index fd4a6546..3fed1ef2 100644 --- a/definitions/standard/runtime_definition/array/std_array_index_of.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_index_of.proto.json @@ -99,7 +99,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Get index of ${item} in ${list }" + "content": "Get index of ${item} in ${list}" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/array/std_array_map.proto.json b/definitions/standard/runtime_definition/array/std_array_map.proto.json index 421c9bf4..ca4d3438 100644 --- a/definitions/standard/runtime_definition/array/std_array_map.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_map.proto.json @@ -4,7 +4,7 @@ { "dataTypeIdentifier": { "genericType": { - "dataTypeIdentifier": "LISt", + "dataTypeIdentifier": "LIST", "genericMappers": [ { "source": [ diff --git a/definitions/standard/runtime_definition/boolean/std_boolean_from_text.proto.json b/definitions/standard/runtime_definition/boolean/std_boolean_from_text.proto.json index 1d6ee29e..bf5676b0 100644 --- a/definitions/standard/runtime_definition/boolean/std_boolean_from_text.proto.json +++ b/definitions/standard/runtime_definition/boolean/std_boolean_from_text.proto.json @@ -59,7 +59,7 @@ "displayMessage": [ { "code": "en-US", - "content": "Convert ${value} to number" + "content": "Convert ${value} to boolean" } ], "deprecationMessage": [] diff --git a/definitions/standard/runtime_definition/number/std_number_sin.proto.json b/definitions/standard/runtime_definition/number/std_number_sin.proto.json index 5919df2d..3dece7ba 100644 --- a/definitions/standard/runtime_definition/number/std_number_sin.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_sin.proto.json @@ -5,49 +5,24 @@ "dataTypeIdentifier": { "dataTypeIdentifier": "NUMBER" }, - "runtimeName": "min", + "runtimeName": "value", "defaultValue": null, "name": [ { "code": "en-US", - "content": "Minimum Value" + "content": "Value" } ], "description": [ { "code": "en-US", - "content": "The lower bound of the random number range." + "content": "The number for which to calculate the sine." } ], "documentation": [ { "code": "en-US", - "content": "Defines the minimum value (inclusive) for the random number generation." - } - ] - }, - { - "dataTypeIdentifier": { - "dataTypeIdentifier": "NUMBER" - }, - "runtimeName": "max", - "defaultValue": null, - "name": [ - { - "code": "en-US", - "content": "Maximum Value" - } - ], - "description": [ - { - "code": "en-US", - "content": "The upper bound of the random number range." - } - ], - "documentation": [ - { - "code": "en-US", - "content": "Defines the maximum value (inclusive) for the random number generation." + "content": "Computes the sine of the given number." } ] } @@ -66,13 +41,13 @@ "description": [ { "code": "en-US", - "content": "Generates a random number within the specified range." + "content": "Returns the sine of a number." } ], "documentation": [ { "code": "en-US", - "content": "Returns a pseudo-random number between the given minimum and maximum values." + "content": "Calculates the sine of the input value." } ], "alias": [ @@ -84,7 +59,7 @@ "displayMessage": [ { "code": "en-US", - "content": "sin(${min})" + "content": "sin(${value})" } ], "deprecationMessage": [] From e4a391c4d6e366917afbae94dd5365f2504d4440 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Raphael=20G=C3=B6tz?= <52959657+raphael-goetz@users.noreply.github.com> Date: Thu, 20 Nov 2025 18:25:20 +0100 Subject: [PATCH 07/14] Update definitions/standard/data_type/type/text_encoding.proto.json MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Raphael Götz <52959657+raphael-goetz@users.noreply.github.com> --- .../data_type/type/text_encoding.proto.json | 64 +++++++++---------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/definitions/standard/data_type/type/text_encoding.proto.json b/definitions/standard/data_type/type/text_encoding.proto.json index 662d2138..5acce355 100644 --- a/definitions/standard/data_type/type/text_encoding.proto.json +++ b/definitions/standard/data_type/type/text_encoding.proto.json @@ -1,34 +1,34 @@ { - "variant": "TYPE", - "identifier": "TEXT_ENCODING", - "name": [ - { - "code": "en-US", - "content": "Text Encoding" - } - ], - "alias": [ - { - "code": "en-US", - "content": "text;encoding;base64" - } - ], - "displayMessage": [ - { - "code": "en-US", - "content": "Text Encoding" - } - ], - "rules": [ - { - "itemOfCollection": { - "items": [ - { - "stringValue": "BASE64" - } - ] - } - } - ], - "genericKeys": [] + "variant": "TYPE", + "identifier": "TEXT_ENCODING", + "name": [ + { + "code": "en-US", + "content": "Text Encoding" + } + ], + "alias": [ + { + "code": "en-US", + "content": "text;encoding;base64" + } + ], + "displayMessage": [ + { + "code": "en-US", + "content": "Text Encoding" + } + ], + "rules": [ + { + "itemOfCollection": { + "items": [ + { + "stringValue": "BASE64" + } + ] + } + } + ], + "genericKeys": [] } From bc950854308e232cc4cd0306b4fe245e3b1172fd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Raphael=20G=C3=B6tz?= <52959657+raphael-goetz@users.noreply.github.com> Date: Thu, 20 Nov 2025 18:25:44 +0100 Subject: [PATCH 08/14] Update definitions/standard/runtime_definition/array/std_array_filter.proto.json MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Raphael Götz <52959657+raphael-goetz@users.noreply.github.com> --- .../runtime_definition/array/std_array_filter.proto.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/definitions/standard/runtime_definition/array/std_array_filter.proto.json b/definitions/standard/runtime_definition/array/std_array_filter.proto.json index b9b26b1f..c4d0d6b2 100644 --- a/definitions/standard/runtime_definition/array/std_array_filter.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_filter.proto.json @@ -107,7 +107,7 @@ "description": [ { "code": "en-US", - "content": "Filters elements of an list based on a predicate." + "content": "Filters elements of a list based on a predicate." } ], "documentation": [ From fc93aa90576a89719f843418be955be0b0025bdf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Raphael=20G=C3=B6tz?= <52959657+raphael-goetz@users.noreply.github.com> Date: Thu, 20 Nov 2025 18:26:07 +0100 Subject: [PATCH 09/14] Update definitions/standard/runtime_definition/array/std_array_at.proto.json MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Raphael Götz <52959657+raphael-goetz@users.noreply.github.com> --- .../standard/runtime_definition/array/std_array_at.proto.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/definitions/standard/runtime_definition/array/std_array_at.proto.json b/definitions/standard/runtime_definition/array/std_array_at.proto.json index 9aaa0908..7761a317 100644 --- a/definitions/standard/runtime_definition/array/std_array_at.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_at.proto.json @@ -81,7 +81,7 @@ "description": [ { "code": "en-US", - "content": "Retrieves the element at a specified index from an list." + "content": "Retrieves the element at a specified index from a list." } ], "documentation": [ From fee27883e423c18e04e1e5cd9f50a6ebd99ec67b Mon Sep 17 00:00:00 2001 From: Raphael Date: Thu, 20 Nov 2025 18:30:12 +0100 Subject: [PATCH 10/14] ref: fixed typos --- .../runtime_definition/array/std_array_push.proto.json | 2 +- .../runtime_definition/text/std_text_from_ascii.proto.json | 4 ++-- .../runtime_definition/text/std_text_to_ascii.proto.json | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/definitions/standard/runtime_definition/array/std_array_push.proto.json b/definitions/standard/runtime_definition/array/std_array_push.proto.json index 311d6bbb..52ebe789 100644 --- a/definitions/standard/runtime_definition/array/std_array_push.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_push.proto.json @@ -81,7 +81,7 @@ "description": [ { "code": "en-US", - "content": "Appends an item to the end of an list." + "content": "Appends an item to the end of a list." } ], "documentation": [ diff --git a/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json b/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json index 2e0e9657..80ef2ac2 100644 --- a/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "Converts an list of ASCII codes back into the corresponding text string." + "content": "Converts a list of ASCII codes back into the corresponding text string." } ], "documentation": [ { "code": "en-US", - "content": "Takes an list of numbers where each number is an ASCII code, and returns the string they represent." + "content": "Takes a list of numbers where each number is an ASCII code, and returns the string they represent.", } ], "alias": [ diff --git a/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json b/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json index 90a40168..0c44ff46 100644 --- a/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_to_ascii.proto.json @@ -60,7 +60,7 @@ "documentation": [ { "code": "en-US", - "content": "Returns an list of numbers where each number represents the ASCII code of the corresponding character in the input text." + "content": "Returns a list of numbers where each number represents the ASCII code of the corresponding character in the input text." } ], "alias": [ From c3563eaf21e53e7836745d427e09b0832f010a33 Mon Sep 17 00:00:00 2001 From: Raphael Date: Thu, 20 Nov 2025 18:41:23 +0100 Subject: [PATCH 11/14] ref: removed trailing comma --- .../runtime_definition/text/std_text_from_ascii.proto.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json b/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json index 80ef2ac2..5f3720bc 100644 --- a/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_from_ascii.proto.json @@ -60,7 +60,7 @@ "documentation": [ { "code": "en-US", - "content": "Takes a list of numbers where each number is an ASCII code, and returns the string they represent.", + "content": "Takes a list of numbers where each number is an ASCII code, and returns the string they represent." } ], "alias": [ From 5c3d23c26d02d20e2107b504b95adca42733359c Mon Sep 17 00:00:00 2001 From: Raphael Date: Fri, 21 Nov 2025 12:25:19 +0100 Subject: [PATCH 12/14] ref: fixed typos --- .../standard/runtime_definition/array/std_array_at.proto.json | 2 +- .../runtime_definition/array/std_array_flat.proto.json | 2 +- .../runtime_definition/array/std_array_index_of.proto.json | 2 +- .../runtime_definition/array/std_array_join.proto.json | 2 +- .../runtime_definition/array/std_array_max.proto.json | 2 +- .../runtime_definition/array/std_array_min.proto.json | 2 +- .../runtime_definition/array/std_array_remove.proto.json | 2 +- .../runtime_definition/array/std_array_reverse.proto.json | 2 +- .../runtime_definition/array/std_array_sort.proto.json | 2 +- .../array/std_array_sort_reverse.proto.json | 2 +- .../runtime_definition/array/std_array_sum.proto.json | 2 +- .../runtime_definition/array/std_array_to_unique.proto.json | 2 +- .../runtime_definition/number/std_number_sin.proto.json | 2 +- .../runtime_definition/text/std_text_split.proto.json | 4 ++-- 14 files changed, 15 insertions(+), 15 deletions(-) diff --git a/definitions/standard/runtime_definition/array/std_array_at.proto.json b/definitions/standard/runtime_definition/array/std_array_at.proto.json index 7761a317..8d3e3310 100644 --- a/definitions/standard/runtime_definition/array/std_array_at.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_at.proto.json @@ -35,7 +35,7 @@ "documentation": [ { "code": "en-US", - "content": "An list containing elements of any type. The element at the specified index will be returned." + "content": "A list containing elements of any type. The element at the specified index will be returned." } ] }, diff --git a/definitions/standard/runtime_definition/array/std_array_flat.proto.json b/definitions/standard/runtime_definition/array/std_array_flat.proto.json index 8d52344b..23914913 100644 --- a/definitions/standard/runtime_definition/array/std_array_flat.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_flat.proto.json @@ -48,7 +48,7 @@ "documentation": [ { "code": "en-US", - "content": "An list containing sub-lists that will be flattened into a single-level list." + "content": "A list containing sub-lists that will be flattened into a single-level list." } ] } diff --git a/definitions/standard/runtime_definition/array/std_array_index_of.proto.json b/definitions/standard/runtime_definition/array/std_array_index_of.proto.json index 3fed1ef2..cc6abfd4 100644 --- a/definitions/standard/runtime_definition/array/std_array_index_of.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_index_of.proto.json @@ -35,7 +35,7 @@ "documentation": [ { "code": "en-US", - "content": "An list of elements in which the specified item will be searched for to determine its index." + "content": "A list of elements in which the specified item will be searched for to determine its index." } ] }, diff --git a/definitions/standard/runtime_definition/array/std_array_join.proto.json b/definitions/standard/runtime_definition/array/std_array_join.proto.json index 5adfc294..3665d9ef 100644 --- a/definitions/standard/runtime_definition/array/std_array_join.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_join.proto.json @@ -29,7 +29,7 @@ "description": [ { "code": "en-US", - "content": "An list of text elements to be filtered." + "content": "A list of text elements to be filtered." } ], "documentation": [ diff --git a/definitions/standard/runtime_definition/array/std_array_max.proto.json b/definitions/standard/runtime_definition/array/std_array_max.proto.json index 4aca276a..a6e371fa 100644 --- a/definitions/standard/runtime_definition/array/std_array_max.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_max.proto.json @@ -29,7 +29,7 @@ "description": [ { "code": "en-US", - "content": "An list of numbers to find the maximum value from." + "content": "A list of numbers to find the maximum value from." } ], "documentation": [ diff --git a/definitions/standard/runtime_definition/array/std_array_min.proto.json b/definitions/standard/runtime_definition/array/std_array_min.proto.json index 6af5cb98..d9a3495a 100644 --- a/definitions/standard/runtime_definition/array/std_array_min.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_min.proto.json @@ -29,7 +29,7 @@ "description": [ { "code": "en-US", - "content": "An list of numbers to find the minimum value from." + "content": "A list of numbers to find the minimum value from." } ], "documentation": [ diff --git a/definitions/standard/runtime_definition/array/std_array_remove.proto.json b/definitions/standard/runtime_definition/array/std_array_remove.proto.json index 7edae221..271c5b0c 100644 --- a/definitions/standard/runtime_definition/array/std_array_remove.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_remove.proto.json @@ -35,7 +35,7 @@ "documentation": [ { "code": "en-US", - "content": "An list to process by removing the first occurrence of the specified item." + "content": "A list to process by removing the first occurrence of the specified item." } ] }, diff --git a/definitions/standard/runtime_definition/array/std_array_reverse.proto.json b/definitions/standard/runtime_definition/array/std_array_reverse.proto.json index 9b3b1e63..5f2b65ce 100644 --- a/definitions/standard/runtime_definition/array/std_array_reverse.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_reverse.proto.json @@ -35,7 +35,7 @@ "documentation": [ { "code": "en-US", - "content": "An list of elements whose order will be reversed." + "content": "A list of elements whose order will be reversed." } ] } diff --git a/definitions/standard/runtime_definition/array/std_array_sort.proto.json b/definitions/standard/runtime_definition/array/std_array_sort.proto.json index 0686f846..6fdd8c6a 100644 --- a/definitions/standard/runtime_definition/array/std_array_sort.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sort.proto.json @@ -35,7 +35,7 @@ "documentation": [ { "code": "en-US", - "content": "An list of elements that will be sorted using the provided comparator function." + "content": "A list of elements that will be sorted using the provided comparator function." } ] }, diff --git a/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json b/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json index 92e83ea9..0939cf17 100644 --- a/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sort_reverse.proto.json @@ -35,7 +35,7 @@ "documentation": [ { "code": "en-US", - "content": "An list of elements that will be sorted in descending order using the provided comparator." + "content": "A list of elements that will be sorted in descending order using the provided comparator." } ] }, diff --git a/definitions/standard/runtime_definition/array/std_array_sum.proto.json b/definitions/standard/runtime_definition/array/std_array_sum.proto.json index 6cbda643..54775297 100644 --- a/definitions/standard/runtime_definition/array/std_array_sum.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_sum.proto.json @@ -28,7 +28,7 @@ "description": [ { "code": "en-US", - "content": "An list of numbers to be summed." + "content": "A list of numbers to be summed." } ], "documentation": [ diff --git a/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json b/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json index 99a685d0..2d0b2a3a 100644 --- a/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json +++ b/definitions/standard/runtime_definition/array/std_array_to_unique.proto.json @@ -35,7 +35,7 @@ "documentation": [ { "code": "en-US", - "content": "An list of elements that may contain duplicates. This function will remove any duplicate items and return a new list with unique values only." + "content": "A list of elements that may contain duplicates. This function will remove any duplicate items and return a new list with unique values only." } ] } diff --git a/definitions/standard/runtime_definition/number/std_number_sin.proto.json b/definitions/standard/runtime_definition/number/std_number_sin.proto.json index 3dece7ba..28b73928 100644 --- a/definitions/standard/runtime_definition/number/std_number_sin.proto.json +++ b/definitions/standard/runtime_definition/number/std_number_sin.proto.json @@ -35,7 +35,7 @@ "name": [ { "code": "en-US", - "content": "Random Number" + "content": "Sine" } ], "description": [ diff --git a/definitions/standard/runtime_definition/text/std_text_split.proto.json b/definitions/standard/runtime_definition/text/std_text_split.proto.json index a84e4971..a7b9953e 100644 --- a/definitions/standard/runtime_definition/text/std_text_split.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_split.proto.json @@ -79,13 +79,13 @@ "description": [ { "code": "en-US", - "content": "Splits the input text into an list of substrings based on the specified delimiter." + "content": "Splits the input text into a list of substrings based on the specified delimiter." } ], "documentation": [ { "code": "en-US", - "content": "Returns an list of substrings obtained by splitting the input text at each occurrence of the delimiter." + "content": "Returns a list of substrings obtained by splitting the input text at each occurrence of the delimiter." } ], "alias": [ From 4b97633421547d6783ee1eda232dddcb9ccc61c2 Mon Sep 17 00:00:00 2001 From: raphael-goetz Date: Sat, 22 Nov 2025 14:34:51 +0100 Subject: [PATCH 13/14] fix: requested grammer fixes --- .../runtime_definition/text/std_text_as_bytes.proto.json | 6 +++--- .../runtime_definition/text/std_text_chars.proto.json | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json b/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json index 272d2e61..ed04ae4c 100644 --- a/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_as_bytes.proto.json @@ -22,7 +22,7 @@ "documentation": [ { "code": "en-US", - "content": "Converts the input text string into an list of byte values." + "content": "Converts the input text string into a list of byte values." } ] } @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "Converts a text string into an list of byte values." + "content": "Converts a text string into a list of byte values." } ], "documentation": [ { "code": "en-US", - "content": "Returns an list of bytes representing the UTF-8 encoding of the given text." + "content": "Returns a list of bytes representing the UTF-8 encoding of the given text." } ], "alias": [ diff --git a/definitions/standard/runtime_definition/text/std_text_chars.proto.json b/definitions/standard/runtime_definition/text/std_text_chars.proto.json index e8d31adf..7813b3ef 100644 --- a/definitions/standard/runtime_definition/text/std_text_chars.proto.json +++ b/definitions/standard/runtime_definition/text/std_text_chars.proto.json @@ -22,7 +22,7 @@ "documentation": [ { "code": "en-US", - "content": "Splits the input text string into an list of its constituent characters." + "content": "Splits the input text string into a list of its constituent characters." } ] } @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "Returns an list containing each character from the given text string." + "content": "Returns a list containing each character from the given text string." } ], "documentation": [ { "code": "en-US", - "content": "Creates an list where each element is a single character from the original text." + "content": "Creates a list where each element is a single character from the original text." } ], "alias": [ From 523b796d23b3ba0e5c915168d8ba8fb76ed41796 Mon Sep 17 00:00:00 2001 From: raphael-goetz Date: Wed, 26 Nov 2025 15:59:33 +0100 Subject: [PATCH 14/14] fix: requested grammar fixes --- .../runtime_definition/object/std_object_keys.proto.json | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/definitions/standard/runtime_definition/object/std_object_keys.proto.json b/definitions/standard/runtime_definition/object/std_object_keys.proto.json index 519633f4..7cc5034e 100644 --- a/definitions/standard/runtime_definition/object/std_object_keys.proto.json +++ b/definitions/standard/runtime_definition/object/std_object_keys.proto.json @@ -22,7 +22,7 @@ "documentation": [ { "code": "en-US", - "content": "Returns an list of all the keys (property names) of the given object." + "content": "Returns a list of all the keys (property names) of the given object." } ] } @@ -54,13 +54,13 @@ "description": [ { "code": "en-US", - "content": "Retrieves all the keys from the given object as an list of text values." + "content": "Retrieves all the keys from the given object as a list of text values." } ], "documentation": [ { "code": "en-US", - "content": "Returns an list containing all enumerable property names (keys) of the specified object." + "content": "Returns a list containing all enumerable property names (keys) of the specified object." } ], "alias": [