@code0-tech/tucana 0.0.0 → 0.0.38

package/pb/shared.data_type_pb.ts

@@ -0,0 +1,1534 @@
+// @generated by protobuf-ts 2.11.1 with parameter add_pb_suffix
+// @generated from protobuf file "shared.data_type.proto" (package "shared", syntax proto3)
+// tslint:disable
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+import { Value } from "./shared.struct_pb";
+import { Version } from "./shared.version_pb";
+import { Translation } from "./shared.translation_pb";
+/**
+ *
+ * A data type is a custom implementation that could be compared to an object
+ * It could be as simple as a primitive but can be as complex as a structured object with rules
+ *
+ * @generated from protobuf message shared.DefinitionDataType
+ */
+export interface DefinitionDataType {
+    /**
+     * Variant of the data type
+     *
+     * @generated from protobuf field: shared.DefinitionDataType.Variant variant = 1
+     */
+    variant: DefinitionDataType_Variant;
+    /**
+     * Unique identifier of the data type
+     *
+     * @generated from protobuf field: string identifier = 2
+     */
+    identifier: string;
+    /**
+     * @generated from protobuf field: repeated shared.Translation name = 3
+     */
+    name: Translation[];
+    /**
+     * Rules of the data type (e.g. Regex, contains...)
+     *
+     * @generated from protobuf field: repeated shared.DefinitionDataTypeRule rules = 4
+     */
+    rules: DefinitionDataTypeRule[];
+    /**
+     * List of generic keys
+     *
+     * @generated from protobuf field: repeated string generic_keys = 5
+     */
+    genericKeys: string[];
+    /**
+     * Version of the data type
+     *
+     * @generated from protobuf field: shared.Version version = 6
+     */
+    version?: Version;
+}
+/**
+ * @generated from protobuf enum shared.DefinitionDataType.Variant
+ */
+export enum DefinitionDataType_Variant {
+    /**
+     * @generated from protobuf enum value: UNKNOWN = 0;
+     */
+    UNKNOWN = 0,
+    /**
+     * @generated from protobuf enum value: PRIMITIVE = 1;
+     */
+    PRIMITIVE = 1,
+    /**
+     * @generated from protobuf enum value: TYPE = 2;
+     */
+    TYPE = 2,
+    /**
+     * @generated from protobuf enum value: OBJECT = 3;
+     */
+    OBJECT = 3,
+    /**
+     * @generated from protobuf enum value: DATATYPE = 4;
+     */
+    DATATYPE = 4,
+    /**
+     * @generated from protobuf enum value: ARRAY = 5;
+     */
+    ARRAY = 5,
+    /**
+     * @generated from protobuf enum value: ERROR = 6;
+     */
+    ERROR = 6,
+    /**
+     * @generated from protobuf enum value: NODE = 7;
+     */
+    NODE = 7
+}
+/**
+ * @generated from protobuf message shared.ExecutionDataType
+ */
+export interface ExecutionDataType {
+    /**
+     * Unique identifier of the data type
+     *
+     * @generated from protobuf field: string identifier = 1
+     */
+    identifier: string;
+    /**
+     * Rules of the data type (e.g. Regex, contains...)
+     *
+     * @generated from protobuf field: repeated shared.ExecutionDataTypeRule rules = 2
+     */
+    rules: ExecutionDataTypeRule[];
+}
+/**
+ * @generated from protobuf message shared.DefinitionDataTypeRule
+ */
+export interface DefinitionDataTypeRule {
+    /**
+     * @generated from protobuf oneof: config
+     */
+    config: {
+        oneofKind: "containsKey";
+        /**
+         * @generated from protobuf field: shared.DefinitionDataTypeContainsKeyRuleConfig contains_key = 1
+         */
+        containsKey: DefinitionDataTypeContainsKeyRuleConfig;
+    } | {
+        oneofKind: "containsType";
+        /**
+         * @generated from protobuf field: shared.DefinitionDataTypeContainsTypeRuleConfig contains_type = 2
+         */
+        containsType: DefinitionDataTypeContainsTypeRuleConfig;
+    } | {
+        oneofKind: "itemOfCollection";
+        /**
+         * @generated from protobuf field: shared.DataTypeItemOfCollectionRuleConfig item_of_collection = 3
+         */
+        itemOfCollection: DataTypeItemOfCollectionRuleConfig;
+    } | {
+        oneofKind: "numberRange";
+        /**
+         * @generated from protobuf field: shared.DataTypeNumberRangeRuleConfig number_range = 4
+         */
+        numberRange: DataTypeNumberRangeRuleConfig;
+    } | {
+        oneofKind: "regex";
+        /**
+         * @generated from protobuf field: shared.DataTypeRegexRuleConfig regex = 5
+         */
+        regex: DataTypeRegexRuleConfig;
+    } | {
+        oneofKind: "inputTypes";
+        /**
+         * @generated from protobuf field: shared.DefinitionDataTypeInputTypesRuleConfig input_types = 6
+         */
+        inputTypes: DefinitionDataTypeInputTypesRuleConfig;
+    } | {
+        oneofKind: "returnType";
+        /**
+         * @generated from protobuf field: shared.DefinitionDataTypeReturnTypeRuleConfig return_type = 7
+         */
+        returnType: DefinitionDataTypeReturnTypeRuleConfig;
+    } | {
+        oneofKind: "parentType";
+        /**
+         * @generated from protobuf field: shared.DefinitionDataTypeParentTypeRuleConfig parent_type = 8
+         */
+        parentType: DefinitionDataTypeParentTypeRuleConfig;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message shared.ExecutionDataTypeRule
+ */
+export interface ExecutionDataTypeRule {
+    /**
+     * @generated from protobuf oneof: config
+     */
+    config: {
+        oneofKind: "containsKey";
+        /**
+         * @generated from protobuf field: shared.ExecutionDataTypeContainsKeyRuleConfig contains_key = 1
+         */
+        containsKey: ExecutionDataTypeContainsKeyRuleConfig;
+    } | {
+        oneofKind: "containsType";
+        /**
+         * @generated from protobuf field: shared.ExecutionDataTypeContainsTypeRuleConfig contains_type = 2
+         */
+        containsType: ExecutionDataTypeContainsTypeRuleConfig;
+    } | {
+        oneofKind: "itemOfCollection";
+        /**
+         * @generated from protobuf field: shared.DataTypeItemOfCollectionRuleConfig item_of_collection = 3
+         */
+        itemOfCollection: DataTypeItemOfCollectionRuleConfig;
+    } | {
+        oneofKind: "numberRange";
+        /**
+         * @generated from protobuf field: shared.DataTypeNumberRangeRuleConfig number_range = 4
+         */
+        numberRange: DataTypeNumberRangeRuleConfig;
+    } | {
+        oneofKind: "regex";
+        /**
+         * @generated from protobuf field: shared.DataTypeRegexRuleConfig regex = 5
+         */
+        regex: DataTypeRegexRuleConfig;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * Rule for defining the data type parent type
+ *
+ * @generated from protobuf message shared.DefinitionDataTypeParentTypeRuleConfig
+ */
+export interface DefinitionDataTypeParentTypeRuleConfig {
+    /**
+     * @generated from protobuf field: shared.DataTypeIdentifier parent_type = 1
+     */
+    parentType?: DataTypeIdentifier;
+}
+/**
+ * Rule to check that the given key is contained in the given object
+ *
+ * @generated from protobuf message shared.DefinitionDataTypeContainsKeyRuleConfig
+ */
+export interface DefinitionDataTypeContainsKeyRuleConfig {
+    /**
+     * @generated from protobuf field: string key = 1
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: shared.DataTypeIdentifier data_type_identifier = 2
+     */
+    dataTypeIdentifier?: DataTypeIdentifier;
+}
+/**
+ * @generated from protobuf message shared.ExecutionDataTypeContainsKeyRuleConfig
+ */
+export interface ExecutionDataTypeContainsKeyRuleConfig {
+    /**
+     * @generated from protobuf field: string key = 1
+     */
+    key: string;
+    /**
+     * @generated from protobuf field: string data_type_identifier = 2
+     */
+    dataTypeIdentifier: string;
+}
+/**
+ * Rule to check that the given type is contained in the given array
+ *
+ * @generated from protobuf message shared.DefinitionDataTypeContainsTypeRuleConfig
+ */
+export interface DefinitionDataTypeContainsTypeRuleConfig {
+    /**
+     * @generated from protobuf field: shared.DataTypeIdentifier data_type_identifier = 1
+     */
+    dataTypeIdentifier?: DataTypeIdentifier;
+}
+/**
+ * @generated from protobuf message shared.ExecutionDataTypeContainsTypeRuleConfig
+ */
+export interface ExecutionDataTypeContainsTypeRuleConfig {
+    /**
+     * @generated from protobuf field: string data_type_identifier = 1
+     */
+    dataTypeIdentifier: string;
+}
+/**
+ * Rule to check that the given item is contained inside the array of items
+ *
+ * @generated from protobuf message shared.DataTypeItemOfCollectionRuleConfig
+ */
+export interface DataTypeItemOfCollectionRuleConfig {
+    /**
+     * @generated from protobuf field: repeated shared.Value items = 1
+     */
+    items: Value[];
+}
+/**
+ * Rule to check that the given number is contained inside the range of numbers
+ *
+ * @generated from protobuf message shared.DataTypeNumberRangeRuleConfig
+ */
+export interface DataTypeNumberRangeRuleConfig {
+    /**
+     * @generated from protobuf field: int64 from = 1
+     */
+    from: bigint;
+    /**
+     * @generated from protobuf field: int64 to = 2
+     */
+    to: bigint;
+    /**
+     * @generated from protobuf field: optional int64 steps = 3
+     */
+    steps?: bigint;
+}
+/**
+ * Rule to check that the given string matches the given regex pattern
+ *
+ * @generated from protobuf message shared.DataTypeRegexRuleConfig
+ */
+export interface DataTypeRegexRuleConfig {
+    /**
+     * @generated from protobuf field: string pattern = 1
+     */
+    pattern: string;
+}
+/**
+ * @generated from protobuf message shared.DefinitionDataTypeInputTypesRuleConfig
+ */
+export interface DefinitionDataTypeInputTypesRuleConfig {
+    /**
+     * @generated from protobuf field: repeated shared.DefinitionDataTypeInputTypesRuleConfig.DataTypeInputType input_types = 1
+     */
+    inputTypes: DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType[];
+}
+/**
+ * @generated from protobuf message shared.DefinitionDataTypeInputTypesRuleConfig.DataTypeInputType
+ */
+export interface DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType {
+    /**
+     * @generated from protobuf field: shared.DataTypeIdentifier data_type_identifier = 1
+     */
+    dataTypeIdentifier?: DataTypeIdentifier;
+    /**
+     * @generated from protobuf field: string input_identifier = 2
+     */
+    inputIdentifier: string;
+}
+/**
+ * @generated from protobuf message shared.DefinitionDataTypeReturnTypeRuleConfig
+ */
+export interface DefinitionDataTypeReturnTypeRuleConfig {
+    /**
+     * @generated from protobuf field: shared.DataTypeIdentifier data_type_identifier = 1
+     */
+    dataTypeIdentifier?: DataTypeIdentifier;
+}
+/**
+ * @generated from protobuf message shared.DataTypeIdentifier
+ */
+export interface DataTypeIdentifier {
+    /**
+     * @generated from protobuf oneof: type
+     */
+    type: {
+        oneofKind: "dataTypeIdentifier";
+        /**
+         * Points to a data type without generic keys
+         *
+         * @generated from protobuf field: string data_type_identifier = 1
+         */
+        dataTypeIdentifier: string;
+    } | {
+        oneofKind: "genericType";
+        /**
+         * Points to a data type with generic keys
+         *
+         * @generated from protobuf field: shared.GenericType generic_type = 2
+         */
+        genericType: GenericType;
+    } | {
+        oneofKind: "genericKey";
+        /**
+         * Points to a generic key in the current function
+         *
+         * @generated from protobuf field: string generic_key = 3
+         */
+        genericKey: string;
+    } | {
+        oneofKind: undefined;
+    };
+}
+/**
+ * @generated from protobuf message shared.GenericType
+ */
+export interface GenericType {
+    /**
+     * References a data type by its identifier
+     *
+     * @generated from protobuf field: string data_type_identifier = 1
+     */
+    dataTypeIdentifier: string;
+    /**
+     * @generated from protobuf field: repeated shared.GenericMapper generic_mappers = 2
+     */
+    genericMappers: GenericMapper[];
+}
+/**
+ * target get mapped to source
+ *
+ * @generated from protobuf message shared.GenericMapper
+ */
+export interface GenericMapper {
+    /**
+     * can point to another generic or to a resolved data type
+     * Assigns source to this source
+     *
+     * @generated from protobuf field: repeated shared.DataTypeIdentifier source = 1
+     */
+    source: DataTypeIdentifier[];
+    /**
+     * can only be a generic key for example: 'T', 'V'
+     *
+     * @generated from protobuf field: string target = 2
+     */
+    target: string;
+    /**
+     * @generated from protobuf field: repeated shared.GenericMapper.GenericCombinationStrategy generic_combinations = 3
+     */
+    genericCombinations: GenericMapper_GenericCombinationStrategy[];
+}
+/**
+ * Strategy to combine generic keys
+ *
+ * @generated from protobuf enum shared.GenericMapper.GenericCombinationStrategy
+ */
+export enum GenericMapper_GenericCombinationStrategy {
+    /**
+     * @generated from protobuf enum value: UNKNOWN = 0;
+     */
+    UNKNOWN = 0,
+    /**
+     * @generated from protobuf enum value: AND = 1;
+     */
+    AND = 1,
+    /**
+     * @generated from protobuf enum value: OR = 2;
+     */
+    OR = 2
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class DefinitionDataType$Type extends MessageType<DefinitionDataType> {
+    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: "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 }
+        ]);
+    }
+    create(value?: PartialMessage<DefinitionDataType>): DefinitionDataType {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.variant = 0;
+        message.identifier = "";
+        message.name = [];
+        message.rules = [];
+        message.genericKeys = [];
+        if (value !== undefined)
+            reflectionMergePartial<DefinitionDataType>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DefinitionDataType): DefinitionDataType {
+        let message = target ?? this.create(), end = reader.pos + length;
+        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:
+                    message.identifier = reader.string();
+                    break;
+                case /* repeated shared.Translation name */ 3:
+                    message.name.push(Translation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated shared.DefinitionDataTypeRule rules */ 4:
+                    message.rules.push(DefinitionDataTypeRule.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated string generic_keys */ 5:
+                    message.genericKeys.push(reader.string());
+                    break;
+                case /* shared.Version version */ 6:
+                    message.version = Version.internalBinaryRead(reader, reader.uint32(), options, message.version);
+                    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: DefinitionDataType, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* shared.DefinitionDataType.Variant variant = 1; */
+        if (message.variant !== 0)
+            writer.tag(1, WireType.Varint).int32(message.variant);
+        /* string identifier = 2; */
+        if (message.identifier !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.identifier);
+        /* 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; */
+        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; */
+        for (let i = 0; i < message.genericKeys.length; i++)
+            writer.tag(5, WireType.LengthDelimited).string(message.genericKeys[i]);
+        /* shared.Version version = 6; */
+        if (message.version)
+            Version.internalBinaryWrite(message.version, writer.tag(6, 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.DefinitionDataType
+ */
+export const DefinitionDataType = new DefinitionDataType$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionDataType$Type extends MessageType<ExecutionDataType> {
+    constructor() {
+        super("shared.ExecutionDataType", [
+            { no: 1, name: "identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "rules", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => ExecutionDataTypeRule }
+        ]);
+    }
+    create(value?: PartialMessage<ExecutionDataType>): ExecutionDataType {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.identifier = "";
+        message.rules = [];
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionDataType>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionDataType): ExecutionDataType {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string identifier */ 1:
+                    message.identifier = reader.string();
+                    break;
+                case /* repeated shared.ExecutionDataTypeRule rules */ 2:
+                    message.rules.push(ExecutionDataTypeRule.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: ExecutionDataType, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string identifier = 1; */
+        if (message.identifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.identifier);
+        /* repeated shared.ExecutionDataTypeRule rules = 2; */
+        for (let i = 0; i < message.rules.length; i++)
+            ExecutionDataTypeRule.internalBinaryWrite(message.rules[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.ExecutionDataType
+ */
+export const ExecutionDataType = new ExecutionDataType$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DefinitionDataTypeRule$Type extends MessageType<DefinitionDataTypeRule> {
+    constructor() {
+        super("shared.DefinitionDataTypeRule", [
+            { no: 1, name: "contains_key", kind: "message", oneof: "config", T: () => DefinitionDataTypeContainsKeyRuleConfig },
+            { no: 2, name: "contains_type", kind: "message", oneof: "config", T: () => DefinitionDataTypeContainsTypeRuleConfig },
+            { 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: () => DefinitionDataTypeInputTypesRuleConfig },
+            { no: 7, name: "return_type", kind: "message", oneof: "config", T: () => DefinitionDataTypeReturnTypeRuleConfig },
+            { no: 8, name: "parent_type", kind: "message", oneof: "config", T: () => DefinitionDataTypeParentTypeRuleConfig }
+        ]);
+    }
+    create(value?: PartialMessage<DefinitionDataTypeRule>): DefinitionDataTypeRule {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.config = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<DefinitionDataTypeRule>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DefinitionDataTypeRule): DefinitionDataTypeRule {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* shared.DefinitionDataTypeContainsKeyRuleConfig contains_key */ 1:
+                    message.config = {
+                        oneofKind: "containsKey",
+                        containsKey: DefinitionDataTypeContainsKeyRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).containsKey)
+                    };
+                    break;
+                case /* shared.DefinitionDataTypeContainsTypeRuleConfig contains_type */ 2:
+                    message.config = {
+                        oneofKind: "containsType",
+                        containsType: DefinitionDataTypeContainsTypeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).containsType)
+                    };
+                    break;
+                case /* shared.DataTypeItemOfCollectionRuleConfig item_of_collection */ 3:
+                    message.config = {
+                        oneofKind: "itemOfCollection",
+                        itemOfCollection: DataTypeItemOfCollectionRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).itemOfCollection)
+                    };
+                    break;
+                case /* shared.DataTypeNumberRangeRuleConfig number_range */ 4:
+                    message.config = {
+                        oneofKind: "numberRange",
+                        numberRange: DataTypeNumberRangeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).numberRange)
+                    };
+                    break;
+                case /* shared.DataTypeRegexRuleConfig regex */ 5:
+                    message.config = {
+                        oneofKind: "regex",
+                        regex: DataTypeRegexRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).regex)
+                    };
+                    break;
+                case /* shared.DefinitionDataTypeInputTypesRuleConfig input_types */ 6:
+                    message.config = {
+                        oneofKind: "inputTypes",
+                        inputTypes: DefinitionDataTypeInputTypesRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).inputTypes)
+                    };
+                    break;
+                case /* shared.DefinitionDataTypeReturnTypeRuleConfig return_type */ 7:
+                    message.config = {
+                        oneofKind: "returnType",
+                        returnType: DefinitionDataTypeReturnTypeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).returnType)
+                    };
+                    break;
+                case /* shared.DefinitionDataTypeParentTypeRuleConfig parent_type */ 8:
+                    message.config = {
+                        oneofKind: "parentType",
+                        parentType: DefinitionDataTypeParentTypeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).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: DefinitionDataTypeRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* shared.DefinitionDataTypeContainsKeyRuleConfig contains_key = 1; */
+        if (message.config.oneofKind === "containsKey")
+            DefinitionDataTypeContainsKeyRuleConfig.internalBinaryWrite(message.config.containsKey, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DefinitionDataTypeContainsTypeRuleConfig contains_type = 2; */
+        if (message.config.oneofKind === "containsType")
+            DefinitionDataTypeContainsTypeRuleConfig.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; */
+        if (message.config.oneofKind === "numberRange")
+            DataTypeNumberRangeRuleConfig.internalBinaryWrite(message.config.numberRange, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DataTypeRegexRuleConfig regex = 5; */
+        if (message.config.oneofKind === "regex")
+            DataTypeRegexRuleConfig.internalBinaryWrite(message.config.regex, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DefinitionDataTypeInputTypesRuleConfig input_types = 6; */
+        if (message.config.oneofKind === "inputTypes")
+            DefinitionDataTypeInputTypesRuleConfig.internalBinaryWrite(message.config.inputTypes, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DefinitionDataTypeReturnTypeRuleConfig return_type = 7; */
+        if (message.config.oneofKind === "returnType")
+            DefinitionDataTypeReturnTypeRuleConfig.internalBinaryWrite(message.config.returnType, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DefinitionDataTypeParentTypeRuleConfig parent_type = 8; */
+        if (message.config.oneofKind === "parentType")
+            DefinitionDataTypeParentTypeRuleConfig.internalBinaryWrite(message.config.parentType, writer.tag(8, 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.DefinitionDataTypeRule
+ */
+export const DefinitionDataTypeRule = new DefinitionDataTypeRule$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionDataTypeRule$Type extends MessageType<ExecutionDataTypeRule> {
+    constructor() {
+        super("shared.ExecutionDataTypeRule", [
+            { no: 1, name: "contains_key", kind: "message", oneof: "config", T: () => ExecutionDataTypeContainsKeyRuleConfig },
+            { no: 2, name: "contains_type", kind: "message", oneof: "config", T: () => ExecutionDataTypeContainsTypeRuleConfig },
+            { 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 }
+        ]);
+    }
+    create(value?: PartialMessage<ExecutionDataTypeRule>): ExecutionDataTypeRule {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.config = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionDataTypeRule>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionDataTypeRule): ExecutionDataTypeRule {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* shared.ExecutionDataTypeContainsKeyRuleConfig contains_key */ 1:
+                    message.config = {
+                        oneofKind: "containsKey",
+                        containsKey: ExecutionDataTypeContainsKeyRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).containsKey)
+                    };
+                    break;
+                case /* shared.ExecutionDataTypeContainsTypeRuleConfig contains_type */ 2:
+                    message.config = {
+                        oneofKind: "containsType",
+                        containsType: ExecutionDataTypeContainsTypeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).containsType)
+                    };
+                    break;
+                case /* shared.DataTypeItemOfCollectionRuleConfig item_of_collection */ 3:
+                    message.config = {
+                        oneofKind: "itemOfCollection",
+                        itemOfCollection: DataTypeItemOfCollectionRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).itemOfCollection)
+                    };
+                    break;
+                case /* shared.DataTypeNumberRangeRuleConfig number_range */ 4:
+                    message.config = {
+                        oneofKind: "numberRange",
+                        numberRange: DataTypeNumberRangeRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).numberRange)
+                    };
+                    break;
+                case /* shared.DataTypeRegexRuleConfig regex */ 5:
+                    message.config = {
+                        oneofKind: "regex",
+                        regex: DataTypeRegexRuleConfig.internalBinaryRead(reader, reader.uint32(), options, (message.config as any).regex)
+                    };
+                    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: ExecutionDataTypeRule, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* shared.ExecutionDataTypeContainsKeyRuleConfig contains_key = 1; */
+        if (message.config.oneofKind === "containsKey")
+            ExecutionDataTypeContainsKeyRuleConfig.internalBinaryWrite(message.config.containsKey, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* shared.ExecutionDataTypeContainsTypeRuleConfig contains_type = 2; */
+        if (message.config.oneofKind === "containsType")
+            ExecutionDataTypeContainsTypeRuleConfig.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; */
+        if (message.config.oneofKind === "numberRange")
+            DataTypeNumberRangeRuleConfig.internalBinaryWrite(message.config.numberRange, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+        /* shared.DataTypeRegexRuleConfig regex = 5; */
+        if (message.config.oneofKind === "regex")
+            DataTypeRegexRuleConfig.internalBinaryWrite(message.config.regex, writer.tag(5, 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.ExecutionDataTypeRule
+ */
+export const ExecutionDataTypeRule = new ExecutionDataTypeRule$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DefinitionDataTypeParentTypeRuleConfig$Type extends MessageType<DefinitionDataTypeParentTypeRuleConfig> {
+    constructor() {
+        super("shared.DefinitionDataTypeParentTypeRuleConfig", [
+            { no: 1, name: "parent_type", kind: "message", T: () => DataTypeIdentifier }
+        ]);
+    }
+    create(value?: PartialMessage<DefinitionDataTypeParentTypeRuleConfig>): DefinitionDataTypeParentTypeRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<DefinitionDataTypeParentTypeRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DefinitionDataTypeParentTypeRuleConfig): DefinitionDataTypeParentTypeRuleConfig {
+        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: DefinitionDataTypeParentTypeRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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.DefinitionDataTypeParentTypeRuleConfig
+ */
+export const DefinitionDataTypeParentTypeRuleConfig = new DefinitionDataTypeParentTypeRuleConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DefinitionDataTypeContainsKeyRuleConfig$Type extends MessageType<DefinitionDataTypeContainsKeyRuleConfig> {
+    constructor() {
+        super("shared.DefinitionDataTypeContainsKeyRuleConfig", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "data_type_identifier", kind: "message", T: () => DataTypeIdentifier }
+        ]);
+    }
+    create(value?: PartialMessage<DefinitionDataTypeContainsKeyRuleConfig>): DefinitionDataTypeContainsKeyRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        if (value !== undefined)
+            reflectionMergePartial<DefinitionDataTypeContainsKeyRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DefinitionDataTypeContainsKeyRuleConfig): DefinitionDataTypeContainsKeyRuleConfig {
+        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: DefinitionDataTypeContainsKeyRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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.DefinitionDataTypeContainsKeyRuleConfig
+ */
+export const DefinitionDataTypeContainsKeyRuleConfig = new DefinitionDataTypeContainsKeyRuleConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionDataTypeContainsKeyRuleConfig$Type extends MessageType<ExecutionDataTypeContainsKeyRuleConfig> {
+    constructor() {
+        super("shared.ExecutionDataTypeContainsKeyRuleConfig", [
+            { no: 1, name: "key", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "data_type_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ExecutionDataTypeContainsKeyRuleConfig>): ExecutionDataTypeContainsKeyRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.key = "";
+        message.dataTypeIdentifier = "";
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionDataTypeContainsKeyRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionDataTypeContainsKeyRuleConfig): ExecutionDataTypeContainsKeyRuleConfig {
+        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 /* string data_type_identifier */ 2:
+                    message.dataTypeIdentifier = 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: ExecutionDataTypeContainsKeyRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string key = 1; */
+        if (message.key !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.key);
+        /* string data_type_identifier = 2; */
+        if (message.dataTypeIdentifier !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.dataTypeIdentifier);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message shared.ExecutionDataTypeContainsKeyRuleConfig
+ */
+export const ExecutionDataTypeContainsKeyRuleConfig = new ExecutionDataTypeContainsKeyRuleConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DefinitionDataTypeContainsTypeRuleConfig$Type extends MessageType<DefinitionDataTypeContainsTypeRuleConfig> {
+    constructor() {
+        super("shared.DefinitionDataTypeContainsTypeRuleConfig", [
+            { no: 1, name: "data_type_identifier", kind: "message", T: () => DataTypeIdentifier }
+        ]);
+    }
+    create(value?: PartialMessage<DefinitionDataTypeContainsTypeRuleConfig>): DefinitionDataTypeContainsTypeRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<DefinitionDataTypeContainsTypeRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DefinitionDataTypeContainsTypeRuleConfig): DefinitionDataTypeContainsTypeRuleConfig {
+        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: DefinitionDataTypeContainsTypeRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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.DefinitionDataTypeContainsTypeRuleConfig
+ */
+export const DefinitionDataTypeContainsTypeRuleConfig = new DefinitionDataTypeContainsTypeRuleConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ExecutionDataTypeContainsTypeRuleConfig$Type extends MessageType<ExecutionDataTypeContainsTypeRuleConfig> {
+    constructor() {
+        super("shared.ExecutionDataTypeContainsTypeRuleConfig", [
+            { no: 1, name: "data_type_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<ExecutionDataTypeContainsTypeRuleConfig>): ExecutionDataTypeContainsTypeRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.dataTypeIdentifier = "";
+        if (value !== undefined)
+            reflectionMergePartial<ExecutionDataTypeContainsTypeRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: ExecutionDataTypeContainsTypeRuleConfig): ExecutionDataTypeContainsTypeRuleConfig {
+        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;
+                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: ExecutionDataTypeContainsTypeRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string data_type_identifier = 1; */
+        if (message.dataTypeIdentifier !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.dataTypeIdentifier);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message shared.ExecutionDataTypeContainsTypeRuleConfig
+ */
+export const ExecutionDataTypeContainsTypeRuleConfig = new ExecutionDataTypeContainsTypeRuleConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DataTypeItemOfCollectionRuleConfig$Type extends MessageType<DataTypeItemOfCollectionRuleConfig> {
+    constructor() {
+        super("shared.DataTypeItemOfCollectionRuleConfig", [
+            { no: 1, name: "items", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => Value }
+        ]);
+    }
+    create(value?: PartialMessage<DataTypeItemOfCollectionRuleConfig>): DataTypeItemOfCollectionRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.items = [];
+        if (value !== undefined)
+            reflectionMergePartial<DataTypeItemOfCollectionRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DataTypeItemOfCollectionRuleConfig): DataTypeItemOfCollectionRuleConfig {
+        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: DataTypeItemOfCollectionRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<DataTypeNumberRangeRuleConfig> {
+    constructor() {
+        super("shared.DataTypeNumberRangeRuleConfig", [
+            { no: 1, name: "from", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 2, name: "to", kind: "scalar", T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ },
+            { no: 3, name: "steps", kind: "scalar", opt: true, T: 3 /*ScalarType.INT64*/, L: 0 /*LongType.BIGINT*/ }
+        ]);
+    }
+    create(value?: PartialMessage<DataTypeNumberRangeRuleConfig>): DataTypeNumberRangeRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.from = 0n;
+        message.to = 0n;
+        if (value !== undefined)
+            reflectionMergePartial<DataTypeNumberRangeRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DataTypeNumberRangeRuleConfig): DataTypeNumberRangeRuleConfig {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* int64 from */ 1:
+                    message.from = reader.int64().toBigInt();
+                    break;
+                case /* int64 to */ 2:
+                    message.to = reader.int64().toBigInt();
+                    break;
+                case /* optional int64 steps */ 3:
+                    message.steps = reader.int64().toBigInt();
+                    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: DataTypeNumberRangeRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* int64 from = 1; */
+        if (message.from !== 0n)
+            writer.tag(1, WireType.Varint).int64(message.from);
+        /* int64 to = 2; */
+        if (message.to !== 0n)
+            writer.tag(2, WireType.Varint).int64(message.to);
+        /* optional int64 steps = 3; */
+        if (message.steps !== undefined)
+            writer.tag(3, WireType.Varint).int64(message.steps);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message shared.DataTypeNumberRangeRuleConfig
+ */
+export const DataTypeNumberRangeRuleConfig = new DataTypeNumberRangeRuleConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DataTypeRegexRuleConfig$Type extends MessageType<DataTypeRegexRuleConfig> {
+    constructor() {
+        super("shared.DataTypeRegexRuleConfig", [
+            { no: 1, name: "pattern", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<DataTypeRegexRuleConfig>): DataTypeRegexRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.pattern = "";
+        if (value !== undefined)
+            reflectionMergePartial<DataTypeRegexRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DataTypeRegexRuleConfig): DataTypeRegexRuleConfig {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string pattern */ 1:
+                    message.pattern = 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: DataTypeRegexRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string pattern = 1; */
+        if (message.pattern !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.pattern);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @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 DefinitionDataTypeInputTypesRuleConfig$Type extends MessageType<DefinitionDataTypeInputTypesRuleConfig> {
+    constructor() {
+        super("shared.DefinitionDataTypeInputTypesRuleConfig", [
+            { no: 1, name: "input_types", kind: "message", repeat: 2 /*RepeatType.UNPACKED*/, T: () => DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType }
+        ]);
+    }
+    create(value?: PartialMessage<DefinitionDataTypeInputTypesRuleConfig>): DefinitionDataTypeInputTypesRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.inputTypes = [];
+        if (value !== undefined)
+            reflectionMergePartial<DefinitionDataTypeInputTypesRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DefinitionDataTypeInputTypesRuleConfig): DefinitionDataTypeInputTypesRuleConfig {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* repeated shared.DefinitionDataTypeInputTypesRuleConfig.DataTypeInputType input_types */ 1:
+                    message.inputTypes.push(DefinitionDataTypeInputTypesRuleConfig_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: DefinitionDataTypeInputTypesRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* repeated shared.DefinitionDataTypeInputTypesRuleConfig.DataTypeInputType input_types = 1; */
+        for (let i = 0; i < message.inputTypes.length; i++)
+            DefinitionDataTypeInputTypesRuleConfig_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.DefinitionDataTypeInputTypesRuleConfig
+ */
+export const DefinitionDataTypeInputTypesRuleConfig = new DefinitionDataTypeInputTypesRuleConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType$Type extends MessageType<DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType> {
+    constructor() {
+        super("shared.DefinitionDataTypeInputTypesRuleConfig.DataTypeInputType", [
+            { no: 1, name: "data_type_identifier", kind: "message", T: () => DataTypeIdentifier },
+            { no: 2, name: "input_identifier", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType>): DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.inputIdentifier = "";
+        if (value !== undefined)
+            reflectionMergePartial<DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType): DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType {
+        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: DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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.DefinitionDataTypeInputTypesRuleConfig.DataTypeInputType
+ */
+export const DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType = new DefinitionDataTypeInputTypesRuleConfig_DataTypeInputType$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DefinitionDataTypeReturnTypeRuleConfig$Type extends MessageType<DefinitionDataTypeReturnTypeRuleConfig> {
+    constructor() {
+        super("shared.DefinitionDataTypeReturnTypeRuleConfig", [
+            { no: 1, name: "data_type_identifier", kind: "message", T: () => DataTypeIdentifier }
+        ]);
+    }
+    create(value?: PartialMessage<DefinitionDataTypeReturnTypeRuleConfig>): DefinitionDataTypeReturnTypeRuleConfig {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        if (value !== undefined)
+            reflectionMergePartial<DefinitionDataTypeReturnTypeRuleConfig>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DefinitionDataTypeReturnTypeRuleConfig): DefinitionDataTypeReturnTypeRuleConfig {
+        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: DefinitionDataTypeReturnTypeRuleConfig, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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.DefinitionDataTypeReturnTypeRuleConfig
+ */
+export const DefinitionDataTypeReturnTypeRuleConfig = new DefinitionDataTypeReturnTypeRuleConfig$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class DataTypeIdentifier$Type extends MessageType<DataTypeIdentifier> {
+    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?: PartialMessage<DataTypeIdentifier>): DataTypeIdentifier {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.type = { oneofKind: undefined };
+        if (value !== undefined)
+            reflectionMergePartial<DataTypeIdentifier>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: DataTypeIdentifier): DataTypeIdentifier {
+        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 as any).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: DataTypeIdentifier, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<GenericType> {
+    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?: PartialMessage<GenericType>): GenericType {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.dataTypeIdentifier = "";
+        message.genericMappers = [];
+        if (value !== undefined)
+            reflectionMergePartial<GenericType>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GenericType): GenericType {
+        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: GenericType, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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<GenericMapper> {
+    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?: PartialMessage<GenericMapper>): GenericMapper {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.source = [];
+        message.target = "";
+        message.genericCombinations = [];
+        if (value !== undefined)
+            reflectionMergePartial<GenericMapper>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: GenericMapper): GenericMapper {
+        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: GenericMapper, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* 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();