@code0-tech/tucana 0.0.54 → 0.0.55

package/pb/shared.data_type_pb.js

@@ -5,91 +5,35 @@ import { WireType } from "@protobuf-ts/runtime";
 import { UnknownFieldHandler } from "@protobuf-ts/runtime";
 import { reflectionMergePartial } from "@protobuf-ts/runtime";
 import { MessageType } from "@protobuf-ts/runtime";
-import { Value } from "./shared.struct_pb";
 import { Translation } from "./shared.translation_pb";
-/**
- * @generated from protobuf enum shared.DefinitionDataType.Variant
- */
-export var DefinitionDataType_Variant;
-(function (DefinitionDataType_Variant) {
-    /**
-     * @generated from protobuf enum value: UNKNOWN = 0;
-     */
-    DefinitionDataType_Variant[DefinitionDataType_Variant["UNKNOWN"] = 0] = "UNKNOWN";
-    /**
-     * @generated from protobuf enum value: PRIMITIVE = 1;
-     */
-    DefinitionDataType_Variant[DefinitionDataType_Variant["PRIMITIVE"] = 1] = "PRIMITIVE";
-    /**
-     * @generated from protobuf enum value: TYPE = 2;
-     */
-    DefinitionDataType_Variant[DefinitionDataType_Variant["TYPE"] = 2] = "TYPE";
-    /**
-     * @generated from protobuf enum value: OBJECT = 3;
-     */
-    DefinitionDataType_Variant[DefinitionDataType_Variant["OBJECT"] = 3] = "OBJECT";
-    /**
-     * @generated from protobuf enum value: DATATYPE = 4;
-     */
-    DefinitionDataType_Variant[DefinitionDataType_Variant["DATATYPE"] = 4] = "DATATYPE";
-    /**
-     * @generated from protobuf enum value: ARRAY = 5;
-     */
-    DefinitionDataType_Variant[DefinitionDataType_Variant["ARRAY"] = 5] = "ARRAY";
-    /**
-     * @generated from protobuf enum value: ERROR = 6;
-     */
-    DefinitionDataType_Variant[DefinitionDataType_Variant["ERROR"] = 6] = "ERROR";
-    /**
-     * @generated from protobuf enum value: NODE = 7;
-     */
-    DefinitionDataType_Variant[DefinitionDataType_Variant["NODE"] = 7] = "NODE";
-})(DefinitionDataType_Variant || (DefinitionDataType_Variant = {}));
-/**
- * Strategy to combine generic keys
- *
- * @generated from protobuf enum shared.GenericMapper.GenericCombinationStrategy
- */
-export var GenericMapper_GenericCombinationStrategy;
-(function (GenericMapper_GenericCombinationStrategy) {
-    /**
-     * @generated from protobuf enum value: UNKNOWN = 0;
-     */
-    GenericMapper_GenericCombinationStrategy[GenericMapper_GenericCombinationStrategy["UNKNOWN"] = 0] = "UNKNOWN";
-    /**
-     * @generated from protobuf enum value: AND = 1;
-     */
-    GenericMapper_GenericCombinationStrategy[GenericMapper_GenericCombinationStrategy["AND"] = 1] = "AND";
-    /**
-     * @generated from protobuf enum value: OR = 2;
-     */
-    GenericMapper_GenericCombinationStrategy[GenericMapper_GenericCombinationStrategy["OR"] = 2] = "OR";
-})(GenericMapper_GenericCombinationStrategy || (GenericMapper_GenericCombinationStrategy = {}));
 // @generated message type with reflection information, may provide speed optimized methods
 class DefinitionDataType$Type extends MessageType {
     constructor() {
         super("shared.DefinitionDataType", [
-            { 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: "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: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 9, name: "definition_source", kind: "scalar", opt: true, T: 9 /*ScalarType.STRING*/ }
+            { no: 1, name: "identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "name", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 3, name: "display_message", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 4, name: "alias", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Translation },
+            { no: 5, name: "rules", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DefinitionDataTypeRule },
+            { no: 6, name: "generic_keys", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 7, name: "signature", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 8, name: "linked_data_type_identifiers", kind: "scalar", repeat: 2 /*RepeatType.UNPACKED*/, T: 9 /*ScalarType.STRING*/ },
+            { no: 9, name: "version", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 10, name: "definition_source", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
         ]);
     }
     create(value) {
         const message = globalThis.Object.create((this.messagePrototype));
-        message.variant = 0;
         message.identifier = "";
         message.name = [];
         message.displayMessage = [];
         message.alias = [];
         message.rules = [];
         message.genericKeys = [];
+        message.signature = "";
+        message.linkedDataTypeIdentifiers = [];
         message.version = "";
+        message.definitionSource = "";
         if (value !== undefined)
             reflectionMergePartial(this, message, value);
         return message;
@@ -99,31 +43,34 @@ class DefinitionDataType$Type extends MessageType {
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
-                case /* shared.DefinitionDataType.Variant variant */ 1:
-                    message.variant = reader.int32();
-                    break;
-                case /* string identifier */ 2:
+                case /* string identifier */ 1:
                     message.identifier = reader.string();
                     break;
-                case /* repeated shared.Translation name */ 3:
+                case /* repeated shared.Translation name */ 2:
                     message.name.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
                     break;
-                case /* repeated shared.Translation display_message */ 4:
+                case /* repeated shared.Translation display_message */ 3:
                     message.displayMessage.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
                     break;
-                case /* repeated shared.Translation alias */ 5:
+                case /* repeated shared.Translation alias */ 4:
                     message.alias.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
                     break;
-                case /* repeated shared.DefinitionDataTypeRule rules */ 6:
+                case /* repeated shared.DefinitionDataTypeRule rules */ 5:
                     message.rules.push(DefinitionDataTypeRule.internalBinaryRead(reader, reader.uint32(), options));
                     break;
-                case /* repeated string generic_keys */ 7:
+                case /* repeated string generic_keys */ 6:
                     message.genericKeys.push(reader.string());
                     break;
-                case /* string version */ 8:
+                case /* string signature */ 7:
+                    message.signature = reader.string();
+                    break;
+                case /* repeated string linked_data_type_identifiers */ 8:
+                    message.linkedDataTypeIdentifiers.push(reader.string());
+                    break;
+                case /* string version */ 9:
                     message.version = reader.string();
                     break;
-                case /* optional string definition_source */ 9:
+                case /* string definition_source */ 10:
                     message.definitionSource = reader.string();
                     break;
                 default:
@@ -138,33 +85,36 @@ class DefinitionDataType$Type extends MessageType {
         return message;
     }
     internalBinaryWrite(message, writer, options) {
-        /* shared.DefinitionDataType.Variant variant = 1; */
-        if (message.variant !== 0)
-            writer.tag(1, WireType.Varint).int32(message.variant);
-        /* string identifier = 2; */
+        /* string identifier = 1; */
         if (message.identifier !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.identifier);
-        /* repeated shared.Translation name = 3; */
+            writer.tag(1, WireType.LengthDelimited).string(message.identifier);
+        /* repeated shared.Translation name = 2; */
         for (let i = 0; i < message.name.length; i++)
-            Translation.internalBinaryWrite(message.name[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
-        /* repeated shared.Translation display_message = 4; */
+            Translation.internalBinaryWrite(message.name[i], writer.tag(2, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.Translation display_message = 3; */
         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; */
+            Translation.internalBinaryWrite(message.displayMessage[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.Translation alias = 4; */
         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; */
+            Translation.internalBinaryWrite(message.alias[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* repeated shared.DefinitionDataTypeRule rules = 5; */
         for (let i = 0; i < message.rules.length; i++)
-            DefinitionDataTypeRule.internalBinaryWrite(message.rules[i], writer.tag(6, WireType.LengthDelimited).fork(), options).join();
-        /* repeated string generic_keys = 7; */
+            DefinitionDataTypeRule.internalBinaryWrite(message.rules[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* repeated string generic_keys = 6; */
         for (let i = 0; i < message.genericKeys.length; i++)
-            writer.tag(7, WireType.LengthDelimited).string(message.genericKeys[i]);
-        /* string version = 8; */
+            writer.tag(6, WireType.LengthDelimited).string(message.genericKeys[i]);
+        /* string signature = 7; */
+        if (message.signature !== "")
+            writer.tag(7, WireType.LengthDelimited).string(message.signature);
+        /* repeated string linked_data_type_identifiers = 8; */
+        for (let i = 0; i < message.linkedDataTypeIdentifiers.length; i++)
+            writer.tag(8, WireType.LengthDelimited).string(message.linkedDataTypeIdentifiers[i]);
+        /* string version = 9; */
         if (message.version !== "")
-            writer.tag(8, WireType.LengthDelimited).string(message.version);
-        /* optional string definition_source = 9; */
-        if (message.definitionSource !== undefined)
-            writer.tag(9, WireType.LengthDelimited).string(message.definitionSource);
+            writer.tag(9, WireType.LengthDelimited).string(message.version);
+        /* string definition_source = 10; */
+        if (message.definitionSource !== "")
+            writer.tag(10, WireType.LengthDelimited).string(message.definitionSource);
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -234,14 +184,8 @@ export const ExecutionDataType = new ExecutionDataType$Type();
 class DefinitionDataTypeRule$Type extends MessageType {
     constructor() {
         super("shared.DefinitionDataTypeRule", [
-            { no: 1, name: "contains_key", kind: "message", oneof: "config", T: () => DataTypeContainsKeyRuleConfig },
-            { no: 2, name: "contains_type", kind: "message", oneof: "config", T: () => DataTypeContainsTypeRuleConfig },
-            { no: 3, name: "item_of_collection", kind: "message", oneof: "config", T: () => DataTypeItemOfCollectionRuleConfig },
-            { no: 4, name: "number_range", kind: "message", oneof: "config", T: () => DataTypeNumberRangeRuleConfig },
-            { no: 5, name: "regex", kind: "message", oneof: "config", T: () => DataTypeRegexRuleConfig },
-            { no: 6, name: "input_types", kind: "message", oneof: "config", T: () => DataTypeInputTypesRuleConfig },
-            { no: 7, name: "return_type", kind: "message", oneof: "config", T: () => DataTypeReturnTypeRuleConfig },
-            { no: 8, name: "parent_type", kind: "message", oneof: "config", T: () => DataTypeParentTypeRuleConfig }
+            { no: 1, name: "number_range", kind: "message", oneof: "config", T: () => DataTypeNumberRangeRuleConfig },
+            { no: 2, name: "regex", kind: "message", oneof: "config", T: () => DataTypeRegexRuleConfig }
         ]);
     }
     create(value) {
@@ -256,54 +200,18 @@ class DefinitionDataTypeRule$Type extends MessageType {
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
-                case /* shared.DataTypeContainsKeyRuleConfig contains_key */ 1:
-                    message.config = {
-                        oneofKind: "containsKey",
-                        containsKey: DataTypeContainsKeyRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.containsKey)
-                    };
-                    break;
-                case /* shared.DataTypeContainsTypeRuleConfig contains_type */ 2:
-                    message.config = {
-                        oneofKind: "containsType",
-                        containsType: DataTypeContainsTypeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.containsType)
-                    };
-                    break;
-                case /* shared.DataTypeItemOfCollectionRuleConfig item_of_collection */ 3:
-                    message.config = {
-                        oneofKind: "itemOfCollection",
-                        itemOfCollection: DataTypeItemOfCollectionRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.itemOfCollection)
-                    };
-                    break;
-                case /* shared.DataTypeNumberRangeRuleConfig number_range */ 4:
+                case /* shared.DataTypeNumberRangeRuleConfig number_range */ 1:
                     message.config = {
                         oneofKind: "numberRange",
                         numberRange: DataTypeNumberRangeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.numberRange)
                     };
                     break;
-                case /* shared.DataTypeRegexRuleConfig regex */ 5:
+                case /* shared.DataTypeRegexRuleConfig regex */ 2:
                     message.config = {
                         oneofKind: "regex",
                         regex: DataTypeRegexRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.regex)
                     };
                     break;
-                case /* shared.DataTypeInputTypesRuleConfig input_types */ 6:
-                    message.config = {
-                        oneofKind: "inputTypes",
-                        inputTypes: DataTypeInputTypesRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.inputTypes)
-                    };
-                    break;
-                case /* shared.DataTypeReturnTypeRuleConfig return_type */ 7:
-                    message.config = {
-                        oneofKind: "returnType",
-                        returnType: DataTypeReturnTypeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.returnType)
-                    };
-                    break;
-                case /* shared.DataTypeParentTypeRuleConfig parent_type */ 8:
-                    message.config = {
-                        oneofKind: "parentType",
-                        parentType: DataTypeParentTypeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.parentType)
-                    };
-                    break;
                 default:
                     let u = options.readUnknownField;
                     if (u === "throw")
@@ -316,30 +224,12 @@ class DefinitionDataTypeRule$Type extends MessageType {
         return message;
     }
     internalBinaryWrite(message, writer, options) {
-        /* shared.DataTypeContainsKeyRuleConfig contains_key = 1; */
-        if (message.config.oneofKind === "containsKey")
-            DataTypeContainsKeyRuleConfig.internalBinaryWrite(message.config.containsKey, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeContainsTypeRuleConfig contains_type = 2; */
-        if (message.config.oneofKind === "containsType")
-            DataTypeContainsTypeRuleConfig.internalBinaryWrite(message.config.containsType, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeItemOfCollectionRuleConfig item_of_collection = 3; */
-        if (message.config.oneofKind === "itemOfCollection")
-            DataTypeItemOfCollectionRuleConfig.internalBinaryWrite(message.config.itemOfCollection, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeNumberRangeRuleConfig number_range = 4; */
+        /* shared.DataTypeNumberRangeRuleConfig number_range = 1; */
         if (message.config.oneofKind === "numberRange")
-            DataTypeNumberRangeRuleConfig.internalBinaryWrite(message.config.numberRange, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeRegexRuleConfig regex = 5; */
+            DataTypeNumberRangeRuleConfig.internalBinaryWrite(message.config.numberRange, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DataTypeRegexRuleConfig regex = 2; */
         if (message.config.oneofKind === "regex")
-            DataTypeRegexRuleConfig.internalBinaryWrite(message.config.regex, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeInputTypesRuleConfig input_types = 6; */
-        if (message.config.oneofKind === "inputTypes")
-            DataTypeInputTypesRuleConfig.internalBinaryWrite(message.config.inputTypes, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeReturnTypeRuleConfig return_type = 7; */
-        if (message.config.oneofKind === "returnType")
-            DataTypeReturnTypeRuleConfig.internalBinaryWrite(message.config.returnType, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeParentTypeRuleConfig parent_type = 8; */
-        if (message.config.oneofKind === "parentType")
-            DataTypeParentTypeRuleConfig.internalBinaryWrite(message.config.parentType, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+            DataTypeRegexRuleConfig.internalBinaryWrite(message.config.regex, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -354,11 +244,8 @@ export const DefinitionDataTypeRule = new DefinitionDataTypeRule$Type();
 class ExecutionDataTypeRule$Type extends MessageType {
     constructor() {
         super("shared.ExecutionDataTypeRule", [
-            { no: 1, name: "contains_key", kind: "message", oneof: "config", T: () => DataTypeContainsKeyRuleConfig },
-            { no: 2, name: "contains_type", kind: "message", oneof: "config", T: () => DataTypeContainsTypeRuleConfig },
-            { no: 3, name: "item_of_collection", kind: "message", oneof: "config", T: () => DataTypeItemOfCollectionRuleConfig },
-            { no: 4, name: "number_range", kind: "message", oneof: "config", T: () => DataTypeNumberRangeRuleConfig },
-            { no: 5, name: "regex", kind: "message", oneof: "config", T: () => DataTypeRegexRuleConfig }
+            { no: 1, name: "number_range", kind: "message", oneof: "config", T: () => DataTypeNumberRangeRuleConfig },
+            { no: 2, name: "regex", kind: "message", oneof: "config", T: () => DataTypeRegexRuleConfig }
         ]);
     }
     create(value) {
@@ -373,31 +260,13 @@ class ExecutionDataTypeRule$Type extends MessageType {
         while (reader.pos < end) {
             let [fieldNo, wireType] = reader.tag();
             switch (fieldNo) {
-                case /* shared.DataTypeContainsKeyRuleConfig contains_key */ 1:
-                    message.config = {
-                        oneofKind: "containsKey",
-                        containsKey: DataTypeContainsKeyRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.containsKey)
-                    };
-                    break;
-                case /* shared.DataTypeContainsTypeRuleConfig contains_type */ 2:
-                    message.config = {
-                        oneofKind: "containsType",
-                        containsType: DataTypeContainsTypeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.containsType)
-                    };
-                    break;
-                case /* shared.DataTypeItemOfCollectionRuleConfig item_of_collection */ 3:
-                    message.config = {
-                        oneofKind: "itemOfCollection",
-                        itemOfCollection: DataTypeItemOfCollectionRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.itemOfCollection)
-                    };
-                    break;
-                case /* shared.DataTypeNumberRangeRuleConfig number_range */ 4:
+                case /* shared.DataTypeNumberRangeRuleConfig number_range */ 1:
                     message.config = {
                         oneofKind: "numberRange",
                         numberRange: DataTypeNumberRangeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.numberRange)
                     };
                     break;
-                case /* shared.DataTypeRegexRuleConfig regex */ 5:
+                case /* shared.DataTypeRegexRuleConfig regex */ 2:
                     message.config = {
                         oneofKind: "regex",
                         regex: DataTypeRegexRuleConfig.internalBinaryRead(reader, reader.uint32(), options, message.config.regex)
@@ -415,21 +284,12 @@ class ExecutionDataTypeRule$Type extends MessageType {
         return message;
     }
     internalBinaryWrite(message, writer, options) {
-        /* shared.DataTypeContainsKeyRuleConfig contains_key = 1; */
-        if (message.config.oneofKind === "containsKey")
-            DataTypeContainsKeyRuleConfig.internalBinaryWrite(message.config.containsKey, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeContainsTypeRuleConfig contains_type = 2; */
-        if (message.config.oneofKind === "containsType")
-            DataTypeContainsTypeRuleConfig.internalBinaryWrite(message.config.containsType, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeItemOfCollectionRuleConfig item_of_collection = 3; */
-        if (message.config.oneofKind === "itemOfCollection")
-            DataTypeItemOfCollectionRuleConfig.internalBinaryWrite(message.config.itemOfCollection, writer.tag(3, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeNumberRangeRuleConfig number_range = 4; */
+        /* shared.DataTypeNumberRangeRuleConfig number_range = 1; */
         if (message.config.oneofKind === "numberRange")
-            DataTypeNumberRangeRuleConfig.internalBinaryWrite(message.config.numberRange, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
-        /* shared.DataTypeRegexRuleConfig regex = 5; */
+            DataTypeNumberRangeRuleConfig.internalBinaryWrite(message.config.numberRange, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DataTypeRegexRuleConfig regex = 2; */
         if (message.config.oneofKind === "regex")
-            DataTypeRegexRuleConfig.internalBinaryWrite(message.config.regex, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+            DataTypeRegexRuleConfig.internalBinaryWrite(message.config.regex, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
         let u = options.writeUnknownFields;
         if (u !== false)
             (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
@@ -441,199 +301,6 @@ class ExecutionDataTypeRule$Type extends MessageType {
  */
 export const ExecutionDataTypeRule = new ExecutionDataTypeRule$Type();
 // @generated message type with reflection information, may provide speed optimized methods
-class DataTypeParentTypeRuleConfig$Type extends MessageType {
-    constructor() {
-        super("shared.DataTypeParentTypeRuleConfig", [
-            { no: 1, name: "parent_type", kind: "message", T: () => DataTypeIdentifier }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* shared.DataTypeIdentifier parent_type */ 1:
-                    message.parentType = DataTypeIdentifier.internalBinaryRead(reader, reader.uint32(), options, message.parentType);
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* shared.DataTypeIdentifier parent_type = 1; */
-        if (message.parentType)
-            DataTypeIdentifier.internalBinaryWrite(message.parentType, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.DataTypeParentTypeRuleConfig
- */
-export const DataTypeParentTypeRuleConfig = new DataTypeParentTypeRuleConfig$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class DataTypeContainsKeyRuleConfig$Type extends MessageType {
-    constructor() {
-        super("shared.DataTypeContainsKeyRuleConfig", [
-            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 2, name: "data_type_identifier", kind: "message", T: () => DataTypeIdentifier }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        message.key = "";
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* string key */ 1:
-                    message.key = reader.string();
-                    break;
-                case /* shared.DataTypeIdentifier data_type_identifier */ 2:
-                    message.dataTypeIdentifier = DataTypeIdentifier.internalBinaryRead(reader, reader.uint32(), options, message.dataTypeIdentifier);
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* string key = 1; */
-        if (message.key !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.key);
-        /* shared.DataTypeIdentifier data_type_identifier = 2; */
-        if (message.dataTypeIdentifier)
-            DataTypeIdentifier.internalBinaryWrite(message.dataTypeIdentifier, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.DataTypeContainsKeyRuleConfig
- */
-export const DataTypeContainsKeyRuleConfig = new DataTypeContainsKeyRuleConfig$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class DataTypeContainsTypeRuleConfig$Type extends MessageType {
-    constructor() {
-        super("shared.DataTypeContainsTypeRuleConfig", [
-            { no: 1, name: "data_type_identifier", kind: "message", T: () => DataTypeIdentifier }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* shared.DataTypeIdentifier data_type_identifier */ 1:
-                    message.dataTypeIdentifier = DataTypeIdentifier.internalBinaryRead(reader, reader.uint32(), options, message.dataTypeIdentifier);
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* shared.DataTypeIdentifier data_type_identifier = 1; */
-        if (message.dataTypeIdentifier)
-            DataTypeIdentifier.internalBinaryWrite(message.dataTypeIdentifier, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.DataTypeContainsTypeRuleConfig
- */
-export const DataTypeContainsTypeRuleConfig = new DataTypeContainsTypeRuleConfig$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class DataTypeItemOfCollectionRuleConfig$Type extends MessageType {
-    constructor() {
-        super("shared.DataTypeItemOfCollectionRuleConfig", [
-            { no: 1, name: "items", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Value }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        message.items = [];
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* repeated shared.Value items */ 1:
-                    message.items.push(Value.internalBinaryRead(reader, reader.uint32(), options));
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* repeated shared.Value items = 1; */
-        for (let i = 0; i < message.items.length; i++)
-            Value.internalBinaryWrite(message.items[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.DataTypeItemOfCollectionRuleConfig
- */
-export const DataTypeItemOfCollectionRuleConfig = new DataTypeItemOfCollectionRuleConfig$Type();
-// @generated message type with reflection information, may provide speed optimized methods
 class DataTypeNumberRangeRuleConfig$Type extends MessageType {
     constructor() {
         super("shared.DataTypeNumberRangeRuleConfig", [
@@ -742,346 +409,3 @@ class DataTypeRegexRuleConfig$Type extends MessageType {
  * @generated MessageType for protobuf message shared.DataTypeRegexRuleConfig
  */
 export const DataTypeRegexRuleConfig = new DataTypeRegexRuleConfig$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class DataTypeInputTypesRuleConfig$Type extends MessageType {
-    constructor() {
-        super("shared.DataTypeInputTypesRuleConfig", [
-            { no: 1, name: "input_types", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DataTypeInputTypesRuleConfig_DataTypeInputType }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        message.inputTypes = [];
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* repeated shared.DataTypeInputTypesRuleConfig.DataTypeInputType input_types */ 1:
-                    message.inputTypes.push(DataTypeInputTypesRuleConfig_DataTypeInputType.internalBinaryRead(reader, reader.uint32(), options));
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* repeated shared.DataTypeInputTypesRuleConfig.DataTypeInputType input_types = 1; */
-        for (let i = 0; i < message.inputTypes.length; i++)
-            DataTypeInputTypesRuleConfig_DataTypeInputType.internalBinaryWrite(message.inputTypes[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.DataTypeInputTypesRuleConfig
- */
-export const DataTypeInputTypesRuleConfig = new DataTypeInputTypesRuleConfig$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class DataTypeInputTypesRuleConfig_DataTypeInputType$Type extends MessageType {
-    constructor() {
-        super("shared.DataTypeInputTypesRuleConfig.DataTypeInputType", [
-            { no: 1, name: "data_type_identifier", kind: "message", T: () => DataTypeIdentifier },
-            { no: 2, name: "input_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        message.inputIdentifier = "";
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* shared.DataTypeIdentifier data_type_identifier */ 1:
-                    message.dataTypeIdentifier = DataTypeIdentifier.internalBinaryRead(reader, reader.uint32(), options, message.dataTypeIdentifier);
-                    break;
-                case /* string input_identifier */ 2:
-                    message.inputIdentifier = reader.string();
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* shared.DataTypeIdentifier data_type_identifier = 1; */
-        if (message.dataTypeIdentifier)
-            DataTypeIdentifier.internalBinaryWrite(message.dataTypeIdentifier, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        /* string input_identifier = 2; */
-        if (message.inputIdentifier !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.inputIdentifier);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.DataTypeInputTypesRuleConfig.DataTypeInputType
- */
-export const DataTypeInputTypesRuleConfig_DataTypeInputType = new DataTypeInputTypesRuleConfig_DataTypeInputType$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class DataTypeReturnTypeRuleConfig$Type extends MessageType {
-    constructor() {
-        super("shared.DataTypeReturnTypeRuleConfig", [
-            { no: 1, name: "data_type_identifier", kind: "message", T: () => DataTypeIdentifier }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* shared.DataTypeIdentifier data_type_identifier */ 1:
-                    message.dataTypeIdentifier = DataTypeIdentifier.internalBinaryRead(reader, reader.uint32(), options, message.dataTypeIdentifier);
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* shared.DataTypeIdentifier data_type_identifier = 1; */
-        if (message.dataTypeIdentifier)
-            DataTypeIdentifier.internalBinaryWrite(message.dataTypeIdentifier, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.DataTypeReturnTypeRuleConfig
- */
-export const DataTypeReturnTypeRuleConfig = new DataTypeReturnTypeRuleConfig$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class DataTypeIdentifier$Type extends MessageType {
-    constructor() {
-        super("shared.DataTypeIdentifier", [
-            { no: 1, name: "data_type_identifier", kind: "scalar", oneof: "type", T: 9 /*ScalarType.STRING*/ },
-            { no: 2, name: "generic_type", kind: "message", oneof: "type", T: () => GenericType },
-            { no: 3, name: "generic_key", kind: "scalar", oneof: "type", T: 9 /*ScalarType.STRING*/ }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        message.type = { oneofKind: undefined };
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* string data_type_identifier */ 1:
-                    message.type = {
-                        oneofKind: "dataTypeIdentifier",
-                        dataTypeIdentifier: reader.string()
-                    };
-                    break;
-                case /* shared.GenericType generic_type */ 2:
-                    message.type = {
-                        oneofKind: "genericType",
-                        genericType: GenericType.internalBinaryRead(reader, reader.uint32(), options, message.type.genericType)
-                    };
-                    break;
-                case /* string generic_key */ 3:
-                    message.type = {
-                        oneofKind: "genericKey",
-                        genericKey: reader.string()
-                    };
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* string data_type_identifier = 1; */
-        if (message.type.oneofKind === "dataTypeIdentifier")
-            writer.tag(1, WireType.LengthDelimited).string(message.type.dataTypeIdentifier);
-        /* shared.GenericType generic_type = 2; */
-        if (message.type.oneofKind === "genericType")
-            GenericType.internalBinaryWrite(message.type.genericType, writer.tag(2, WireType.LengthDelimited).fork(), options).join();
-        /* string generic_key = 3; */
-        if (message.type.oneofKind === "genericKey")
-            writer.tag(3, WireType.LengthDelimited).string(message.type.genericKey);
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.DataTypeIdentifier
- */
-export const DataTypeIdentifier = new DataTypeIdentifier$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class GenericType$Type extends MessageType {
-    constructor() {
-        super("shared.GenericType", [
-            { no: 1, name: "data_type_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 2, name: "generic_mappers", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => GenericMapper }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        message.dataTypeIdentifier = "";
-        message.genericMappers = [];
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* string data_type_identifier */ 1:
-                    message.dataTypeIdentifier = reader.string();
-                    break;
-                case /* repeated shared.GenericMapper generic_mappers */ 2:
-                    message.genericMappers.push(GenericMapper.internalBinaryRead(reader, reader.uint32(), options));
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* string data_type_identifier = 1; */
-        if (message.dataTypeIdentifier !== "")
-            writer.tag(1, WireType.LengthDelimited).string(message.dataTypeIdentifier);
-        /* repeated shared.GenericMapper generic_mappers = 2; */
-        for (let i = 0; i < message.genericMappers.length; i++)
-            GenericMapper.internalBinaryWrite(message.genericMappers[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);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.GenericType
- */
-export const GenericType = new GenericType$Type();
-// @generated message type with reflection information, may provide speed optimized methods
-class GenericMapper$Type extends MessageType {
-    constructor() {
-        super("shared.GenericMapper", [
-            { no: 1, name: "source", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DataTypeIdentifier },
-            { no: 2, name: "target", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
-            { no: 3, name: "generic_combinations", kind: "enum", repeat: 1 /*RepeatType.PACKED*/, T: () => ["shared.GenericMapper.GenericCombinationStrategy", GenericMapper_GenericCombinationStrategy] }
-        ]);
-    }
-    create(value) {
-        const message = globalThis.Object.create((this.messagePrototype));
-        message.source = [];
-        message.target = "";
-        message.genericCombinations = [];
-        if (value !== undefined)
-            reflectionMergePartial(this, message, value);
-        return message;
-    }
-    internalBinaryRead(reader, length, options, target) {
-        let message = target ?? this.create(), end = reader.pos + length;
-        while (reader.pos < end) {
-            let [fieldNo, wireType] = reader.tag();
-            switch (fieldNo) {
-                case /* repeated shared.DataTypeIdentifier source */ 1:
-                    message.source.push(DataTypeIdentifier.internalBinaryRead(reader, reader.uint32(), options));
-                    break;
-                case /* string target */ 2:
-                    message.target = reader.string();
-                    break;
-                case /* repeated shared.GenericMapper.GenericCombinationStrategy generic_combinations */ 3:
-                    if (wireType === WireType.LengthDelimited)
-                        for (let e = reader.int32() + reader.pos; reader.pos < e;)
-                            message.genericCombinations.push(reader.int32());
-                    else
-                        message.genericCombinations.push(reader.int32());
-                    break;
-                default:
-                    let u = options.readUnknownField;
-                    if (u === "throw")
-                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
-                    let d = reader.skip(wireType);
-                    if (u !== false)
-                        (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
-            }
-        }
-        return message;
-    }
-    internalBinaryWrite(message, writer, options) {
-        /* repeated shared.DataTypeIdentifier source = 1; */
-        for (let i = 0; i < message.source.length; i++)
-            DataTypeIdentifier.internalBinaryWrite(message.source[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
-        /* string target = 2; */
-        if (message.target !== "")
-            writer.tag(2, WireType.LengthDelimited).string(message.target);
-        /* repeated shared.GenericMapper.GenericCombinationStrategy generic_combinations = 3; */
-        if (message.genericCombinations.length) {
-            writer.tag(3, WireType.LengthDelimited).fork();
-            for (let i = 0; i < message.genericCombinations.length; i++)
-                writer.int32(message.genericCombinations[i]);
-            writer.join();
-        }
-        let u = options.writeUnknownFields;
-        if (u !== false)
-            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
-        return writer;
-    }
-}
-/**
- * @generated MessageType for protobuf message shared.GenericMapper
- */
-export const GenericMapper = new GenericMapper$Type();