@code0-tech/tucana 0.0.39 → 0.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@code0-tech/tucana",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "description": "Code0 GRPC Protocol",
   "homepage": "https://github.com/code0-tech/tucana#readme",
   "bugs": {

package/pb/shared.data_type_pb.d.ts

@@ -34,22 +34,30 @@ export interface DefinitionDataType {
      * @generated from protobuf field: repeated shared.Translation name = 3
      */
     name: Translation[];
+    /**
+     * @generated from protobuf field: repeated shared.Translation display_message = 4
+     */
+    displayMessage: Translation[];
+    /**
+     * @generated from protobuf field: repeated shared.Translation alias = 5
+     */
+    alias: Translation[];
     /**
      * Rules of the data type (e.g. Regex, contains...)
      *
-     * @generated from protobuf field: repeated shared.DefinitionDataTypeRule rules = 4
+     * @generated from protobuf field: repeated shared.DefinitionDataTypeRule rules = 6
      */
     rules: DefinitionDataTypeRule[];
     /**
      * List of generic keys
      *
-     * @generated from protobuf field: repeated string generic_keys = 5
+     * @generated from protobuf field: repeated string generic_keys = 7
      */
     genericKeys: string[];
     /**
      * Version of the data type
      *
-     * @generated from protobuf field: shared.Version version = 6
+     * @generated from protobuf field: shared.Version version = 8
      */
     version?: Version;
 }

package/pb/shared.data_type_pb.js

@@ -73,9 +73,11 @@ class DefinitionDataType$Type extends MessageType {
             { no: 1, name: "variant", kind: "enum", T: () => ["shared.DefinitionDataType.Variant", DefinitionDataType_Variant] },
             { no: 2, name: "identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
             { no: 3, name: "name", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
-            { no: 4, name: "rules", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DefinitionDataTypeRule },
-            { no: 5, name: "generic_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
-            { no: 6, name: "version", kind: "message", T: () => Version }
+            { no: 4, name: "display_message", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 5, name: "alias", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 6, name: "rules", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DefinitionDataTypeRule },
+            { no: 7, name: "generic_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "version", kind: "message", T: () => Version }
         ]);
     }
     create(value) {
@@ -83,6 +85,8 @@ class DefinitionDataType$Type extends MessageType {
         message.variant = 0;
         message.identifier = "";
         message.name = [];
+        message.displayMessage = [];
+        message.alias = [];
         message.rules = [];
         message.genericKeys = [];
         if (value !== undefined)
@@ -103,13 +107,19 @@ class DefinitionDataType$Type extends MessageType {
                 case /* repeated shared.Translation name */ 3:
                     message.name.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
                     break;
-                case /* repeated shared.DefinitionDataTypeRule rules */ 4:
+                case /* repeated shared.Translation display_message */ 4:
+                    message.displayMessage.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated shared.Translation alias */ 5:
+                    message.alias.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated shared.DefinitionDataTypeRule rules */ 6:
                     message.rules.push(DefinitionDataTypeRule.internalBinaryRead(reader, reader.uint32(), options));
                     break;
-                case /* repeated string generic_keys */ 5:
+                case /* repeated string generic_keys */ 7:
                     message.genericKeys.push(reader.string());
                     break;
-                case /* shared.Version version */ 6:
+                case /* shared.Version version */ 8:
                     message.version = Version.internalBinaryRead(reader, reader.uint32(), options, message.version);
                     break;
                 default:
@@ -133,15 +143,21 @@ class DefinitionDataType$Type extends MessageType {
         /* repeated shared.Translation name = 3; */
         for (let i = 0; i < message.name.length; i++)
             Translation.internalBinaryWrite(message.name[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
-        /* repeated shared.DefinitionDataTypeRule rules = 4; */
+        /* repeated shared.Translation display_message = 4; */
+        for (let i = 0; i < message.displayMessage.length; i++)
+            Translation.internalBinaryWrite(message.displayMessage[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.Translation alias = 5; */
+        for (let i = 0; i < message.alias.length; i++)
+            Translation.internalBinaryWrite(message.alias[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.DefinitionDataTypeRule rules = 6; */
         for (let i = 0; i < message.rules.length; i++)
-            DefinitionDataTypeRule.internalBinaryWrite(message.rules[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
-        /* repeated string generic_keys = 5; */
+            DefinitionDataTypeRule.internalBinaryWrite(message.rules[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string generic_keys = 7; */
         for (let i = 0; i < message.genericKeys.length; i++)
-            writer.tag(5, WireType.LengthDelimited).string(message.genericKeys[i]);
-        /* shared.Version version = 6; */
+            writer.tag(7, WireType.LengthDelimited).string(message.genericKeys[i]);
+        /* shared.Version version = 8; */
         if (message.version)
-            Version.internalBinaryWrite(message.version, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+            Version.internalBinaryWrite(message.version, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

package/pb/shared.flow_definition_pb.d.ts

@@ -46,10 +46,18 @@ export interface FlowType {
      * @generated from protobuf field: repeated shared.Translation documentation = 8
      */
     documentation: Translation[];
+    /**
+     * @generated from protobuf field: repeated shared.Translation display_message = 9
+     */
+    displayMessage: Translation[];
+    /**
+     * @generated from protobuf field: repeated shared.Translation alias = 10
+     */
+    alias: Translation[];
     /**
      * Version of the flow type
      *
-     * @generated from protobuf field: shared.Version version = 9
+     * @generated from protobuf field: shared.Version version = 11
      */
     version?: Version;
 }

package/pb/shared.flow_definition_pb.js

@@ -20,7 +20,9 @@ class FlowType$Type extends MessageType {
             { no: 6, name: "name", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
             { no: 7, name: "description", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
             { no: 8, name: "documentation", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
-            { no: 9, name: "version", kind: "message", T: () => Version }
+            { no: 9, name: "display_message", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 10, name: "alias", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 11, name: "version", kind: "message", T: () => Version }
         ]);
     }
     create(value) {
@@ -31,6 +33,8 @@ class FlowType$Type extends MessageType {
         message.name = [];
         message.description = [];
         message.documentation = [];
+        message.displayMessage = [];
+        message.alias = [];
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
         return message;
@@ -64,7 +68,13 @@ class FlowType$Type extends MessageType {
                 case /* repeated shared.Translation documentation */ 8:
                     message.documentation.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
                     break;
-                case /* shared.Version version */ 9:
+                case /* repeated shared.Translation display_message */ 9:
+                    message.displayMessage.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated shared.Translation alias */ 10:
+                    message.alias.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* shared.Version version */ 11:
                     message.version = Version.internalBinaryRead(reader, reader.uint32(), options, message.version);
                     break;
                 default:
@@ -103,9 +113,15 @@ class FlowType$Type extends MessageType {
         /* repeated shared.Translation documentation = 8; */
         for (let i = 0; i < message.documentation.length; i++)
             Translation.internalBinaryWrite(message.documentation[i], writer.tag(8, WireType.LengthDelimited).fork(), options).join();
-        /* shared.Version version = 9; */
+        /* repeated shared.Translation display_message = 9; */
+        for (let i = 0; i < message.displayMessage.length; i++)
+            Translation.internalBinaryWrite(message.displayMessage[i], writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.Translation alias = 10; */
+        for (let i = 0; i < message.alias.length; i++)
+            Translation.internalBinaryWrite(message.alias[i], writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* shared.Version version = 11; */
         if (message.version)
-            Version.internalBinaryWrite(message.version, writer.tag(9, WireType.LengthDelimited).fork(), options).join();
+            Version.internalBinaryWrite(message.version, writer.tag(11, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

package/pb/shared.flow_pb.d.ts

@@ -177,19 +177,13 @@ export interface NodeParameter {
  */
 export interface ReferenceValue {
     /**
-     * @generated from protobuf field: int32 depth = 1
-     */
-    depth: number;
-    /**
-     * @generated from protobuf field: repeated int32 scope = 2
-     */
-    scope: number[];
-    /**
-     * @generated from protobuf field: int32 node = 3
+     * Database Identifier of node
+     *
+     * @generated from protobuf field: int64 node_id = 1
      */
-    node: number;
+    nodeId: bigint;
     /**
-     * @generated from protobuf field: repeated shared.ReferencePath paths = 4
+     * @generated from protobuf field: repeated shared.ReferencePath paths = 2
      */
     paths: ReferencePath[];
 }

package/pb/shared.flow_pb.js

@@ -455,17 +455,13 @@ export const NodeParameter = new NodeParameter$Type();
 class ReferenceValue$Type extends MessageType {
     constructor() {
         super("shared.ReferenceValue", [
-            { no: 1, name: "depth", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
-            { no: 2, name: "scope", kind: "scalar", repeat: 1 /*RepeatType.PACKED*/, T: 5 /*ScalarType.INT32*/ },
-            { no: 3, name: "node", kind: "scalar", T: 5 /*ScalarType.INT32*/ },
-            { no: 4, name: "paths", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReferencePath }
+            { no: 1, name: "node_id", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "paths", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ReferencePath }
         ]);
     }
     create(value) {
         const message = globalThis.Object.create((this.messagePrototype));
-        message.depth = 0;
-        message.scope = [];
-        message.node = 0;
+        message.nodeId = 0n;
         message.paths = [];
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
@@ -476,20 +472,10 @@ class ReferenceValue$Type extends MessageType {
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
-                case /* int32 depth */ 1:
-                    message.depth = reader.int32();
+                case /* int64 node_id */ 1:
+                    message.nodeId = reader.int64().toBigInt();
                     break;
-                case /* repeated int32 scope */ 2:
-                    if (wireType === WireType.LengthDelimited)
-                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
-                            message.scope.push(reader.int32());
-                    else
-                        message.scope.push(reader.int32());
-                    break;
-                case /* int32 node */ 3:
-                    message.node = reader.int32();
-                    break;
-                case /* repeated shared.ReferencePath paths */ 4:
+                case /* repeated shared.ReferencePath paths */ 2:
                     message.paths.push(ReferencePath.internalBinaryRead(reader, reader.uint32(), options));
                     break;
                 default:
@@ -504,22 +490,12 @@ class ReferenceValue$Type extends MessageType {
         return message;
     }
     internalBinaryWrite(message, writer, options) {
-        /* int32 depth = 1; */
-        if (message.depth !== 0)
-            writer.tag(1, WireType.Varint).int32(message.depth);
-        /* repeated int32 scope = 2; */
-        if (message.scope.length) {
-            writer.tag(2, WireType.LengthDelimited).fork();
-            for (let i = 0; i < message.scope.length; i++)
-                writer.int32(message.scope[i]);
-            writer.join();
-        }
-        /* int32 node = 3; */
-        if (message.node !== 0)
-            writer.tag(3, WireType.Varint).int32(message.node);
-        /* repeated shared.ReferencePath paths = 4; */
+        /* int64 node_id = 1; */
+        if (message.nodeId !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.nodeId);
+        /* repeated shared.ReferencePath paths = 2; */
         for (let i = 0; i < message.paths.length; i++)
-            ReferencePath.internalBinaryWrite(message.paths[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+            ReferencePath.internalBinaryWrite(message.paths[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);

package/pb/shared.runtime_function_pb.d.ts

@@ -53,10 +53,18 @@ export interface RuntimeFunctionDefinition {
      * @generated from protobuf field: repeated shared.Translation deprecation_message = 9
      */
     deprecationMessage: Translation[];
+    /**
+     * @generated from protobuf field: repeated shared.Translation display_message = 10
+     */
+    displayMessage: Translation[];
+    /**
+     * @generated from protobuf field: repeated shared.Translation alias = 11
+     */
+    alias: Translation[];
     /**
      * Version of the runtime function
      *
-     * @generated from protobuf field: shared.Version version = 10
+     * @generated from protobuf field: shared.Version version = 12
      */
     version?: Version;
 }

package/pb/shared.runtime_function_pb.js

@@ -22,7 +22,9 @@ class RuntimeFunctionDefinition$Type extends MessageType {
             { no: 7, name: "description", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
             { no: 8, name: "documentation", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
             { no: 9, name: "deprecation_message", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
-            { no: 10, name: "version", kind: "message", T: () => Version }
+            { no: 10, name: "display_message", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 11, name: "alias", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 12, name: "version", kind: "message", T: () => Version }
         ]);
     }
     create(value) {
@@ -35,6 +37,8 @@ class RuntimeFunctionDefinition$Type extends MessageType {
         message.description = [];
         message.documentation = [];
         message.deprecationMessage = [];
+        message.displayMessage = [];
+        message.alias = [];
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
         return message;
@@ -71,7 +75,13 @@ class RuntimeFunctionDefinition$Type extends MessageType {
                 case /* repeated shared.Translation deprecation_message */ 9:
                     message.deprecationMessage.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
                     break;
-                case /* shared.Version version */ 10:
+                case /* repeated shared.Translation display_message */ 10:
+                    message.displayMessage.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated shared.Translation alias */ 11:
+                    message.alias.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* shared.Version version */ 12:
                     message.version = Version.internalBinaryRead(reader, reader.uint32(), options, message.version);
                     break;
                 default:
@@ -113,9 +123,15 @@ class RuntimeFunctionDefinition$Type extends MessageType {
         /* repeated shared.Translation deprecation_message = 9; */
         for (let i = 0; i < message.deprecationMessage.length; i++)
             Translation.internalBinaryWrite(message.deprecationMessage[i], writer.tag(9, WireType.LengthDelimited).fork(), options).join();
-        /* shared.Version version = 10; */
+        /* repeated shared.Translation display_message = 10; */
+        for (let i = 0; i < message.displayMessage.length; i++)
+            Translation.internalBinaryWrite(message.displayMessage[i], writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.Translation alias = 11; */
+        for (let i = 0; i < message.alias.length; i++)
+            Translation.internalBinaryWrite(message.alias[i], writer.tag(11, WireType.LengthDelimited).fork(), options).join();
+        /* shared.Version version = 12; */
         if (message.version)
-            Version.internalBinaryWrite(message.version, writer.tag(10, WireType.LengthDelimited).fork(), options).join();
+            Version.internalBinaryWrite(message.version, writer.tag(12, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);