@canton-network/core-ledger-proto 0.1.0

package/dist/_proto/scalapb/scalapb.js

@@ -0,0 +1,1658 @@
+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 { FieldOptions as FieldOptions$ } from '../google/protobuf/descriptor.js';
+import { FieldDescriptorProto } from '../google/protobuf/descriptor.js';
+/**
+ * Whether to apply the options only to this file, or for the entire package (and its subpackages)
+ *
+ * @generated from protobuf enum scalapb.ScalaPbOptions.OptionsScope
+ */
+export var ScalaPbOptions_OptionsScope;
+(function (ScalaPbOptions_OptionsScope) {
+    /**
+     * Apply the options for this file only (default)
+     *
+     * @generated from protobuf enum value: FILE = 0;
+     */
+    ScalaPbOptions_OptionsScope[ScalaPbOptions_OptionsScope["FILE"] = 0] = "FILE";
+    /**
+     * Apply the options for the entire package and its subpackages.
+     *
+     * @generated from protobuf enum value: PACKAGE = 1;
+     */
+    ScalaPbOptions_OptionsScope[ScalaPbOptions_OptionsScope["PACKAGE"] = 1] = "PACKAGE";
+})(ScalaPbOptions_OptionsScope || (ScalaPbOptions_OptionsScope = {}));
+/**
+ * Naming convention for generated enum values
+ *
+ * @generated from protobuf enum scalapb.ScalaPbOptions.EnumValueNaming
+ */
+export var ScalaPbOptions_EnumValueNaming;
+(function (ScalaPbOptions_EnumValueNaming) {
+    /**
+     * Enum value names in Scala use the same name as in the proto
+     *
+     * @generated from protobuf enum value: AS_IN_PROTO = 0;
+     */
+    ScalaPbOptions_EnumValueNaming[ScalaPbOptions_EnumValueNaming["AS_IN_PROTO"] = 0] = "AS_IN_PROTO";
+    /**
+     * Convert enum values to CamelCase in Scala.
+     *
+     * @generated from protobuf enum value: CAMEL_CASE = 1;
+     */
+    ScalaPbOptions_EnumValueNaming[ScalaPbOptions_EnumValueNaming["CAMEL_CASE"] = 1] = "CAMEL_CASE";
+})(ScalaPbOptions_EnumValueNaming || (ScalaPbOptions_EnumValueNaming = {}));
+/**
+ * @generated from protobuf enum scalapb.MatchType
+ */
+export var MatchType;
+(function (MatchType) {
+    /**
+     * @generated from protobuf enum value: CONTAINS = 0;
+     */
+    MatchType[MatchType["CONTAINS"] = 0] = "CONTAINS";
+    /**
+     * @generated from protobuf enum value: EXACT = 1;
+     */
+    MatchType[MatchType["EXACT"] = 1] = "EXACT";
+    /**
+     * @generated from protobuf enum value: PRESENCE = 2;
+     */
+    MatchType[MatchType["PRESENCE"] = 2] = "PRESENCE";
+})(MatchType || (MatchType = {}));
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalaPbOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.ScalaPbOptions', [
+            {
+                no: 1,
+                name: 'package_name',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'flat_package',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 3,
+                name: 'import',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 4,
+                name: 'preamble',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 5,
+                name: 'single_file',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 7,
+                name: 'no_primitive_wrappers',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 6,
+                name: 'primitive_wrappers',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 8,
+                name: 'collection_type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 9,
+                name: 'preserve_unknown_fields',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 10,
+                name: 'object_name',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 11,
+                name: 'scope',
+                kind: 'enum',
+                opt: true,
+                T: () => [
+                    'scalapb.ScalaPbOptions.OptionsScope',
+                    ScalaPbOptions_OptionsScope,
+                ],
+            },
+            {
+                no: 12,
+                name: 'lenses',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 13,
+                name: 'retain_source_code_info',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 14,
+                name: 'map_type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 15,
+                name: 'no_default_values_in_constructor',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 16,
+                name: 'enum_value_naming',
+                kind: 'enum',
+                opt: true,
+                T: () => [
+                    'scalapb.ScalaPbOptions.EnumValueNaming',
+                    ScalaPbOptions_EnumValueNaming,
+                ],
+            },
+            {
+                no: 17,
+                name: 'enum_strip_prefix',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 21,
+                name: 'bytes_type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 23,
+                name: 'java_conversions',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 18,
+                name: 'aux_message_options',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => ScalaPbOptions_AuxMessageOptions,
+            },
+            {
+                no: 19,
+                name: 'aux_field_options',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => ScalaPbOptions_AuxFieldOptions,
+            },
+            {
+                no: 20,
+                name: 'aux_enum_options',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => ScalaPbOptions_AuxEnumOptions,
+            },
+            {
+                no: 22,
+                name: 'aux_enum_value_options',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => ScalaPbOptions_AuxEnumValueOptions,
+            },
+            {
+                no: 24,
+                name: 'preprocessors',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 25,
+                name: 'field_transformations',
+                kind: 'message',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: () => FieldTransformation,
+            },
+            {
+                no: 26,
+                name: 'ignore_all_transformations',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 27,
+                name: 'getters',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 28,
+                name: 'scala3_sources',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 999,
+                name: 'test_only_no_java_conversions',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.import = [];
+        message.preamble = [];
+        message.auxMessageOptions = [];
+        message.auxFieldOptions = [];
+        message.auxEnumOptions = [];
+        message.auxEnumValueOptions = [];
+        message.preprocessors = [];
+        message.fieldTransformations = [];
+        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 /* optional string package_name */ 1:
+                    message.packageName = reader.string();
+                    break;
+                case /* optional bool flat_package */ 2:
+                    message.flatPackage = reader.bool();
+                    break;
+                case /* repeated string import */ 3:
+                    message.import.push(reader.string());
+                    break;
+                case /* repeated string preamble */ 4:
+                    message.preamble.push(reader.string());
+                    break;
+                case /* optional bool single_file */ 5:
+                    message.singleFile = reader.bool();
+                    break;
+                case /* optional bool no_primitive_wrappers */ 7:
+                    message.noPrimitiveWrappers = reader.bool();
+                    break;
+                case /* optional bool primitive_wrappers */ 6:
+                    message.primitiveWrappers = reader.bool();
+                    break;
+                case /* optional string collection_type */ 8:
+                    message.collectionType = reader.string();
+                    break;
+                case /* optional bool preserve_unknown_fields = 9 [default = true] */ 9:
+                    message.preserveUnknownFields = reader.bool();
+                    break;
+                case /* optional string object_name */ 10:
+                    message.objectName = reader.string();
+                    break;
+                case /* optional scalapb.ScalaPbOptions.OptionsScope scope */ 11:
+                    message.scope = reader.int32();
+                    break;
+                case /* optional bool lenses = 12 [default = true] */ 12:
+                    message.lenses = reader.bool();
+                    break;
+                case /* optional bool retain_source_code_info */ 13:
+                    message.retainSourceCodeInfo = reader.bool();
+                    break;
+                case /* optional string map_type */ 14:
+                    message.mapType = reader.string();
+                    break;
+                case /* optional bool no_default_values_in_constructor */ 15:
+                    message.noDefaultValuesInConstructor = reader.bool();
+                    break;
+                case /* optional scalapb.ScalaPbOptions.EnumValueNaming enum_value_naming */ 16:
+                    message.enumValueNaming = reader.int32();
+                    break;
+                case /* optional bool enum_strip_prefix = 17 [default = false] */ 17:
+                    message.enumStripPrefix = reader.bool();
+                    break;
+                case /* optional string bytes_type */ 21:
+                    message.bytesType = reader.string();
+                    break;
+                case /* optional bool java_conversions */ 23:
+                    message.javaConversions = reader.bool();
+                    break;
+                case /* repeated scalapb.ScalaPbOptions.AuxMessageOptions aux_message_options */ 18:
+                    message.auxMessageOptions.push(ScalaPbOptions_AuxMessageOptions.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated scalapb.ScalaPbOptions.AuxFieldOptions aux_field_options */ 19:
+                    message.auxFieldOptions.push(ScalaPbOptions_AuxFieldOptions.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated scalapb.ScalaPbOptions.AuxEnumOptions aux_enum_options */ 20:
+                    message.auxEnumOptions.push(ScalaPbOptions_AuxEnumOptions.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated scalapb.ScalaPbOptions.AuxEnumValueOptions aux_enum_value_options */ 22:
+                    message.auxEnumValueOptions.push(ScalaPbOptions_AuxEnumValueOptions.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* repeated string preprocessors */ 24:
+                    message.preprocessors.push(reader.string());
+                    break;
+                case /* repeated scalapb.FieldTransformation field_transformations */ 25:
+                    message.fieldTransformations.push(FieldTransformation.internalBinaryRead(reader, reader.uint32(), options));
+                    break;
+                case /* optional bool ignore_all_transformations */ 26:
+                    message.ignoreAllTransformations = reader.bool();
+                    break;
+                case /* optional bool getters = 27 [default = true] */ 27:
+                    message.getters = reader.bool();
+                    break;
+                case /* optional bool scala3_sources */ 28:
+                    message.scala3Sources = reader.bool();
+                    break;
+                case /* optional bool test_only_no_java_conversions */ 999:
+                    message.testOnlyNoJavaConversions = reader.bool();
+                    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) {
+        /* optional string package_name = 1; */
+        if (message.packageName !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.packageName);
+        /* optional bool flat_package = 2; */
+        if (message.flatPackage !== undefined)
+            writer.tag(2, WireType.Varint).bool(message.flatPackage);
+        /* repeated string import = 3; */
+        for (let i = 0; i < message.import.length; i++)
+            writer.tag(3, WireType.LengthDelimited).string(message.import[i]);
+        /* repeated string preamble = 4; */
+        for (let i = 0; i < message.preamble.length; i++)
+            writer.tag(4, WireType.LengthDelimited).string(message.preamble[i]);
+        /* optional bool single_file = 5; */
+        if (message.singleFile !== undefined)
+            writer.tag(5, WireType.Varint).bool(message.singleFile);
+        /* optional bool primitive_wrappers = 6; */
+        if (message.primitiveWrappers !== undefined)
+            writer.tag(6, WireType.Varint).bool(message.primitiveWrappers);
+        /* optional bool no_primitive_wrappers = 7; */
+        if (message.noPrimitiveWrappers !== undefined)
+            writer.tag(7, WireType.Varint).bool(message.noPrimitiveWrappers);
+        /* optional string collection_type = 8; */
+        if (message.collectionType !== undefined)
+            writer
+                .tag(8, WireType.LengthDelimited)
+                .string(message.collectionType);
+        /* optional bool preserve_unknown_fields = 9 [default = true]; */
+        if (message.preserveUnknownFields !== undefined)
+            writer.tag(9, WireType.Varint).bool(message.preserveUnknownFields);
+        /* optional string object_name = 10; */
+        if (message.objectName !== undefined)
+            writer.tag(10, WireType.LengthDelimited).string(message.objectName);
+        /* optional scalapb.ScalaPbOptions.OptionsScope scope = 11; */
+        if (message.scope !== undefined)
+            writer.tag(11, WireType.Varint).int32(message.scope);
+        /* optional bool lenses = 12 [default = true]; */
+        if (message.lenses !== undefined)
+            writer.tag(12, WireType.Varint).bool(message.lenses);
+        /* optional bool retain_source_code_info = 13; */
+        if (message.retainSourceCodeInfo !== undefined)
+            writer.tag(13, WireType.Varint).bool(message.retainSourceCodeInfo);
+        /* optional string map_type = 14; */
+        if (message.mapType !== undefined)
+            writer.tag(14, WireType.LengthDelimited).string(message.mapType);
+        /* optional bool no_default_values_in_constructor = 15; */
+        if (message.noDefaultValuesInConstructor !== undefined)
+            writer
+                .tag(15, WireType.Varint)
+                .bool(message.noDefaultValuesInConstructor);
+        /* optional scalapb.ScalaPbOptions.EnumValueNaming enum_value_naming = 16; */
+        if (message.enumValueNaming !== undefined)
+            writer.tag(16, WireType.Varint).int32(message.enumValueNaming);
+        /* optional bool enum_strip_prefix = 17 [default = false]; */
+        if (message.enumStripPrefix !== undefined)
+            writer.tag(17, WireType.Varint).bool(message.enumStripPrefix);
+        /* repeated scalapb.ScalaPbOptions.AuxMessageOptions aux_message_options = 18; */
+        for (let i = 0; i < message.auxMessageOptions.length; i++)
+            ScalaPbOptions_AuxMessageOptions.internalBinaryWrite(message.auxMessageOptions[i], writer.tag(18, WireType.LengthDelimited).fork(), options).join();
+        /* repeated scalapb.ScalaPbOptions.AuxFieldOptions aux_field_options = 19; */
+        for (let i = 0; i < message.auxFieldOptions.length; i++)
+            ScalaPbOptions_AuxFieldOptions.internalBinaryWrite(message.auxFieldOptions[i], writer.tag(19, WireType.LengthDelimited).fork(), options).join();
+        /* repeated scalapb.ScalaPbOptions.AuxEnumOptions aux_enum_options = 20; */
+        for (let i = 0; i < message.auxEnumOptions.length; i++)
+            ScalaPbOptions_AuxEnumOptions.internalBinaryWrite(message.auxEnumOptions[i], writer.tag(20, WireType.LengthDelimited).fork(), options).join();
+        /* optional string bytes_type = 21; */
+        if (message.bytesType !== undefined)
+            writer.tag(21, WireType.LengthDelimited).string(message.bytesType);
+        /* repeated scalapb.ScalaPbOptions.AuxEnumValueOptions aux_enum_value_options = 22; */
+        for (let i = 0; i < message.auxEnumValueOptions.length; i++)
+            ScalaPbOptions_AuxEnumValueOptions.internalBinaryWrite(message.auxEnumValueOptions[i], writer.tag(22, WireType.LengthDelimited).fork(), options).join();
+        /* optional bool java_conversions = 23; */
+        if (message.javaConversions !== undefined)
+            writer.tag(23, WireType.Varint).bool(message.javaConversions);
+        /* repeated string preprocessors = 24; */
+        for (let i = 0; i < message.preprocessors.length; i++)
+            writer
+                .tag(24, WireType.LengthDelimited)
+                .string(message.preprocessors[i]);
+        /* repeated scalapb.FieldTransformation field_transformations = 25; */
+        for (let i = 0; i < message.fieldTransformations.length; i++)
+            FieldTransformation.internalBinaryWrite(message.fieldTransformations[i], writer.tag(25, WireType.LengthDelimited).fork(), options).join();
+        /* optional bool ignore_all_transformations = 26; */
+        if (message.ignoreAllTransformations !== undefined)
+            writer
+                .tag(26, WireType.Varint)
+                .bool(message.ignoreAllTransformations);
+        /* optional bool getters = 27 [default = true]; */
+        if (message.getters !== undefined)
+            writer.tag(27, WireType.Varint).bool(message.getters);
+        /* optional bool scala3_sources = 28; */
+        if (message.scala3Sources !== undefined)
+            writer.tag(28, WireType.Varint).bool(message.scala3Sources);
+        /* optional bool test_only_no_java_conversions = 999; */
+        if (message.testOnlyNoJavaConversions !== undefined)
+            writer
+                .tag(999, WireType.Varint)
+                .bool(message.testOnlyNoJavaConversions);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message scalapb.ScalaPbOptions
+ */
+export const ScalaPbOptions = new ScalaPbOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalaPbOptions_AuxMessageOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.ScalaPbOptions.AuxMessageOptions', [
+            {
+                no: 1,
+                name: 'target',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'options',
+                kind: 'message',
+                T: () => MessageOptions,
+            },
+        ]);
+    }
+    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 /* optional string target */ 1:
+                    message.target = reader.string();
+                    break;
+                case /* optional scalapb.MessageOptions options */ 2:
+                    message.options = MessageOptions.internalBinaryRead(reader, reader.uint32(), options, message.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) {
+        /* optional string target = 1; */
+        if (message.target !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.target);
+        /* optional scalapb.MessageOptions options = 2; */
+        if (message.options)
+            MessageOptions.internalBinaryWrite(message.options, 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 scalapb.ScalaPbOptions.AuxMessageOptions
+ */
+export const ScalaPbOptions_AuxMessageOptions = new ScalaPbOptions_AuxMessageOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalaPbOptions_AuxFieldOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.ScalaPbOptions.AuxFieldOptions', [
+            {
+                no: 1,
+                name: 'target',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            { no: 2, name: 'options', kind: 'message', T: () => FieldOptions },
+        ]);
+    }
+    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 /* optional string target */ 1:
+                    message.target = reader.string();
+                    break;
+                case /* optional scalapb.FieldOptions options */ 2:
+                    message.options = FieldOptions.internalBinaryRead(reader, reader.uint32(), options, message.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) {
+        /* optional string target = 1; */
+        if (message.target !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.target);
+        /* optional scalapb.FieldOptions options = 2; */
+        if (message.options)
+            FieldOptions.internalBinaryWrite(message.options, 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 scalapb.ScalaPbOptions.AuxFieldOptions
+ */
+export const ScalaPbOptions_AuxFieldOptions = new ScalaPbOptions_AuxFieldOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalaPbOptions_AuxEnumOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.ScalaPbOptions.AuxEnumOptions', [
+            {
+                no: 1,
+                name: 'target',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            { no: 2, name: 'options', kind: 'message', T: () => EnumOptions },
+        ]);
+    }
+    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 /* optional string target */ 1:
+                    message.target = reader.string();
+                    break;
+                case /* optional scalapb.EnumOptions options */ 2:
+                    message.options = EnumOptions.internalBinaryRead(reader, reader.uint32(), options, message.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) {
+        /* optional string target = 1; */
+        if (message.target !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.target);
+        /* optional scalapb.EnumOptions options = 2; */
+        if (message.options)
+            EnumOptions.internalBinaryWrite(message.options, 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 scalapb.ScalaPbOptions.AuxEnumOptions
+ */
+export const ScalaPbOptions_AuxEnumOptions = new ScalaPbOptions_AuxEnumOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ScalaPbOptions_AuxEnumValueOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.ScalaPbOptions.AuxEnumValueOptions', [
+            {
+                no: 1,
+                name: 'target',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'options',
+                kind: 'message',
+                T: () => EnumValueOptions,
+            },
+        ]);
+    }
+    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 /* optional string target */ 1:
+                    message.target = reader.string();
+                    break;
+                case /* optional scalapb.EnumValueOptions options */ 2:
+                    message.options = EnumValueOptions.internalBinaryRead(reader, reader.uint32(), options, message.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) {
+        /* optional string target = 1; */
+        if (message.target !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.target);
+        /* optional scalapb.EnumValueOptions options = 2; */
+        if (message.options)
+            EnumValueOptions.internalBinaryWrite(message.options, 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 scalapb.ScalaPbOptions.AuxEnumValueOptions
+ */
+export const ScalaPbOptions_AuxEnumValueOptions = new ScalaPbOptions_AuxEnumValueOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class MessageOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.MessageOptions', [
+            {
+                no: 1,
+                name: 'extends',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'companion_extends',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'annotations',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 4,
+                name: 'type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 5,
+                name: 'companion_annotations',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 6,
+                name: 'sealed_oneof_extends',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 7,
+                name: 'no_box',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 8,
+                name: 'unknown_fields_annotations',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 9,
+                name: 'no_default_values_in_constructor',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 10,
+                name: 'sealed_oneof_companion_extends',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 11,
+                name: 'derives',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 12,
+                name: 'sealed_oneof_derives',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.extends = [];
+        message.companionExtends = [];
+        message.annotations = [];
+        message.companionAnnotations = [];
+        message.sealedOneofExtends = [];
+        message.unknownFieldsAnnotations = [];
+        message.sealedOneofCompanionExtends = [];
+        message.derives = [];
+        message.sealedOneofDerives = [];
+        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 string extends */ 1:
+                    message.extends.push(reader.string());
+                    break;
+                case /* repeated string companion_extends */ 2:
+                    message.companionExtends.push(reader.string());
+                    break;
+                case /* repeated string annotations */ 3:
+                    message.annotations.push(reader.string());
+                    break;
+                case /* optional string type */ 4:
+                    message.type = reader.string();
+                    break;
+                case /* repeated string companion_annotations */ 5:
+                    message.companionAnnotations.push(reader.string());
+                    break;
+                case /* repeated string sealed_oneof_extends */ 6:
+                    message.sealedOneofExtends.push(reader.string());
+                    break;
+                case /* optional bool no_box */ 7:
+                    message.noBox = reader.bool();
+                    break;
+                case /* repeated string unknown_fields_annotations */ 8:
+                    message.unknownFieldsAnnotations.push(reader.string());
+                    break;
+                case /* optional bool no_default_values_in_constructor */ 9:
+                    message.noDefaultValuesInConstructor = reader.bool();
+                    break;
+                case /* repeated string sealed_oneof_companion_extends */ 10:
+                    message.sealedOneofCompanionExtends.push(reader.string());
+                    break;
+                case /* repeated string derives */ 11:
+                    message.derives.push(reader.string());
+                    break;
+                case /* repeated string sealed_oneof_derives */ 12:
+                    message.sealedOneofDerives.push(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) {
+        /* repeated string extends = 1; */
+        for (let i = 0; i < message.extends.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.extends[i]);
+        /* repeated string companion_extends = 2; */
+        for (let i = 0; i < message.companionExtends.length; i++)
+            writer
+                .tag(2, WireType.LengthDelimited)
+                .string(message.companionExtends[i]);
+        /* repeated string annotations = 3; */
+        for (let i = 0; i < message.annotations.length; i++)
+            writer
+                .tag(3, WireType.LengthDelimited)
+                .string(message.annotations[i]);
+        /* optional string type = 4; */
+        if (message.type !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.type);
+        /* repeated string companion_annotations = 5; */
+        for (let i = 0; i < message.companionAnnotations.length; i++)
+            writer
+                .tag(5, WireType.LengthDelimited)
+                .string(message.companionAnnotations[i]);
+        /* repeated string sealed_oneof_extends = 6; */
+        for (let i = 0; i < message.sealedOneofExtends.length; i++)
+            writer
+                .tag(6, WireType.LengthDelimited)
+                .string(message.sealedOneofExtends[i]);
+        /* optional bool no_box = 7; */
+        if (message.noBox !== undefined)
+            writer.tag(7, WireType.Varint).bool(message.noBox);
+        /* repeated string unknown_fields_annotations = 8; */
+        for (let i = 0; i < message.unknownFieldsAnnotations.length; i++)
+            writer
+                .tag(8, WireType.LengthDelimited)
+                .string(message.unknownFieldsAnnotations[i]);
+        /* optional bool no_default_values_in_constructor = 9; */
+        if (message.noDefaultValuesInConstructor !== undefined)
+            writer
+                .tag(9, WireType.Varint)
+                .bool(message.noDefaultValuesInConstructor);
+        /* repeated string sealed_oneof_companion_extends = 10; */
+        for (let i = 0; i < message.sealedOneofCompanionExtends.length; i++)
+            writer
+                .tag(10, WireType.LengthDelimited)
+                .string(message.sealedOneofCompanionExtends[i]);
+        /* repeated string derives = 11; */
+        for (let i = 0; i < message.derives.length; i++)
+            writer.tag(11, WireType.LengthDelimited).string(message.derives[i]);
+        /* repeated string sealed_oneof_derives = 12; */
+        for (let i = 0; i < message.sealedOneofDerives.length; i++)
+            writer
+                .tag(12, WireType.LengthDelimited)
+                .string(message.sealedOneofDerives[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message scalapb.MessageOptions
+ */
+export const MessageOptions = new MessageOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Collection$Type extends MessageType {
+    constructor() {
+        super('scalapb.Collection', [
+            {
+                no: 1,
+                name: 'type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'non_empty',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 3,
+                name: 'adapter',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    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 /* optional string type */ 1:
+                    message.type = reader.string();
+                    break;
+                case /* optional bool non_empty */ 2:
+                    message.nonEmpty = reader.bool();
+                    break;
+                case /* optional string adapter */ 3:
+                    message.adapter = 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) {
+        /* optional string type = 1; */
+        if (message.type !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.type);
+        /* optional bool non_empty = 2; */
+        if (message.nonEmpty !== undefined)
+            writer.tag(2, WireType.Varint).bool(message.nonEmpty);
+        /* optional string adapter = 3; */
+        if (message.adapter !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.adapter);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message scalapb.Collection
+ */
+export const Collection = new Collection$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FieldOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.FieldOptions', [
+            {
+                no: 1,
+                name: 'type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'scala_name',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'collection_type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            { no: 8, name: 'collection', kind: 'message', T: () => Collection },
+            {
+                no: 4,
+                name: 'key_type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 5,
+                name: 'value_type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 6,
+                name: 'annotations',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 7,
+                name: 'map_type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 9,
+                name: 'no_default_value_in_constructor',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 30,
+                name: 'no_box',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+            {
+                no: 31,
+                name: 'required',
+                kind: 'scalar',
+                opt: true,
+                T: 8 /*ScalarType.BOOL*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.annotations = [];
+        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 /* optional string type */ 1:
+                    message.type = reader.string();
+                    break;
+                case /* optional string scala_name */ 2:
+                    message.scalaName = reader.string();
+                    break;
+                case /* optional string collection_type */ 3:
+                    message.collectionType = reader.string();
+                    break;
+                case /* optional scalapb.Collection collection */ 8:
+                    message.collection = Collection.internalBinaryRead(reader, reader.uint32(), options, message.collection);
+                    break;
+                case /* optional string key_type */ 4:
+                    message.keyType = reader.string();
+                    break;
+                case /* optional string value_type */ 5:
+                    message.valueType = reader.string();
+                    break;
+                case /* repeated string annotations */ 6:
+                    message.annotations.push(reader.string());
+                    break;
+                case /* optional string map_type */ 7:
+                    message.mapType = reader.string();
+                    break;
+                case /* optional bool no_default_value_in_constructor */ 9:
+                    message.noDefaultValueInConstructor = reader.bool();
+                    break;
+                case /* optional bool no_box */ 30:
+                    message.noBox = reader.bool();
+                    break;
+                case /* optional bool required */ 31:
+                    message.required = reader.bool();
+                    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) {
+        /* optional string type = 1; */
+        if (message.type !== undefined)
+            writer.tag(1, WireType.LengthDelimited).string(message.type);
+        /* optional string scala_name = 2; */
+        if (message.scalaName !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.scalaName);
+        /* optional string collection_type = 3; */
+        if (message.collectionType !== undefined)
+            writer
+                .tag(3, WireType.LengthDelimited)
+                .string(message.collectionType);
+        /* optional string key_type = 4; */
+        if (message.keyType !== undefined)
+            writer.tag(4, WireType.LengthDelimited).string(message.keyType);
+        /* optional string value_type = 5; */
+        if (message.valueType !== undefined)
+            writer.tag(5, WireType.LengthDelimited).string(message.valueType);
+        /* repeated string annotations = 6; */
+        for (let i = 0; i < message.annotations.length; i++)
+            writer
+                .tag(6, WireType.LengthDelimited)
+                .string(message.annotations[i]);
+        /* optional string map_type = 7; */
+        if (message.mapType !== undefined)
+            writer.tag(7, WireType.LengthDelimited).string(message.mapType);
+        /* optional scalapb.Collection collection = 8; */
+        if (message.collection)
+            Collection.internalBinaryWrite(message.collection, writer.tag(8, WireType.LengthDelimited).fork(), options).join();
+        /* optional bool no_default_value_in_constructor = 9; */
+        if (message.noDefaultValueInConstructor !== undefined)
+            writer
+                .tag(9, WireType.Varint)
+                .bool(message.noDefaultValueInConstructor);
+        /* optional bool no_box = 30; */
+        if (message.noBox !== undefined)
+            writer.tag(30, WireType.Varint).bool(message.noBox);
+        /* optional bool required = 31; */
+        if (message.required !== undefined)
+            writer.tag(31, WireType.Varint).bool(message.required);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message scalapb.FieldOptions
+ */
+export const FieldOptions = new FieldOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EnumOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.EnumOptions', [
+            {
+                no: 1,
+                name: 'extends',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'companion_extends',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'type',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 4,
+                name: 'base_annotations',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 5,
+                name: 'recognized_annotations',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 6,
+                name: 'unrecognized_annotations',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.extends = [];
+        message.companionExtends = [];
+        message.baseAnnotations = [];
+        message.recognizedAnnotations = [];
+        message.unrecognizedAnnotations = [];
+        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 string extends */ 1:
+                    message.extends.push(reader.string());
+                    break;
+                case /* repeated string companion_extends */ 2:
+                    message.companionExtends.push(reader.string());
+                    break;
+                case /* optional string type */ 3:
+                    message.type = reader.string();
+                    break;
+                case /* repeated string base_annotations */ 4:
+                    message.baseAnnotations.push(reader.string());
+                    break;
+                case /* repeated string recognized_annotations */ 5:
+                    message.recognizedAnnotations.push(reader.string());
+                    break;
+                case /* repeated string unrecognized_annotations */ 6:
+                    message.unrecognizedAnnotations.push(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) {
+        /* repeated string extends = 1; */
+        for (let i = 0; i < message.extends.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.extends[i]);
+        /* repeated string companion_extends = 2; */
+        for (let i = 0; i < message.companionExtends.length; i++)
+            writer
+                .tag(2, WireType.LengthDelimited)
+                .string(message.companionExtends[i]);
+        /* optional string type = 3; */
+        if (message.type !== undefined)
+            writer.tag(3, WireType.LengthDelimited).string(message.type);
+        /* repeated string base_annotations = 4; */
+        for (let i = 0; i < message.baseAnnotations.length; i++)
+            writer
+                .tag(4, WireType.LengthDelimited)
+                .string(message.baseAnnotations[i]);
+        /* repeated string recognized_annotations = 5; */
+        for (let i = 0; i < message.recognizedAnnotations.length; i++)
+            writer
+                .tag(5, WireType.LengthDelimited)
+                .string(message.recognizedAnnotations[i]);
+        /* repeated string unrecognized_annotations = 6; */
+        for (let i = 0; i < message.unrecognizedAnnotations.length; i++)
+            writer
+                .tag(6, WireType.LengthDelimited)
+                .string(message.unrecognizedAnnotations[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message scalapb.EnumOptions
+ */
+export const EnumOptions = new EnumOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class EnumValueOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.EnumValueOptions', [
+            {
+                no: 1,
+                name: 'extends',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'scala_name',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 3,
+                name: 'annotations',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.extends = [];
+        message.annotations = [];
+        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 string extends */ 1:
+                    message.extends.push(reader.string());
+                    break;
+                case /* optional string scala_name */ 2:
+                    message.scalaName = reader.string();
+                    break;
+                case /* repeated string annotations */ 3:
+                    message.annotations.push(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) {
+        /* repeated string extends = 1; */
+        for (let i = 0; i < message.extends.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.extends[i]);
+        /* optional string scala_name = 2; */
+        if (message.scalaName !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.scalaName);
+        /* repeated string annotations = 3; */
+        for (let i = 0; i < message.annotations.length; i++)
+            writer
+                .tag(3, WireType.LengthDelimited)
+                .string(message.annotations[i]);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message scalapb.EnumValueOptions
+ */
+export const EnumValueOptions = new EnumValueOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class OneofOptions$Type extends MessageType {
+    constructor() {
+        super('scalapb.OneofOptions', [
+            {
+                no: 1,
+                name: 'extends',
+                kind: 'scalar',
+                repeat: 2 /*RepeatType.UNPACKED*/,
+                T: 9 /*ScalarType.STRING*/,
+            },
+            {
+                no: 2,
+                name: 'scala_name',
+                kind: 'scalar',
+                opt: true,
+                T: 9 /*ScalarType.STRING*/,
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.extends = [];
+        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 string extends */ 1:
+                    message.extends.push(reader.string());
+                    break;
+                case /* optional string scala_name */ 2:
+                    message.scalaName = 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) {
+        /* repeated string extends = 1; */
+        for (let i = 0; i < message.extends.length; i++)
+            writer.tag(1, WireType.LengthDelimited).string(message.extends[i]);
+        /* optional string scala_name = 2; */
+        if (message.scalaName !== undefined)
+            writer.tag(2, WireType.LengthDelimited).string(message.scalaName);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message scalapb.OneofOptions
+ */
+export const OneofOptions = new OneofOptions$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class FieldTransformation$Type extends MessageType {
+    constructor() {
+        super('scalapb.FieldTransformation', [
+            {
+                no: 1,
+                name: 'when',
+                kind: 'message',
+                T: () => FieldDescriptorProto,
+            },
+            {
+                no: 2,
+                name: 'match_type',
+                kind: 'enum',
+                opt: true,
+                T: () => ['scalapb.MatchType', MatchType],
+            },
+            { no: 3, name: 'set', kind: 'message', T: () => FieldOptions$ },
+        ]);
+    }
+    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 /* optional google.protobuf.FieldDescriptorProto when */ 1:
+                    message.when = FieldDescriptorProto.internalBinaryRead(reader, reader.uint32(), options, message.when);
+                    break;
+                case /* optional scalapb.MatchType match_type = 2 [default = CONTAINS] */ 2:
+                    message.matchType = reader.int32();
+                    break;
+                case /* optional google.protobuf.FieldOptions set */ 3:
+                    message.set = FieldOptions$.internalBinaryRead(reader, reader.uint32(), options, message.set);
+                    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) {
+        /* optional google.protobuf.FieldDescriptorProto when = 1; */
+        if (message.when)
+            FieldDescriptorProto.internalBinaryWrite(message.when, writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+        /* optional scalapb.MatchType match_type = 2 [default = CONTAINS]; */
+        if (message.matchType !== undefined)
+            writer.tag(2, WireType.Varint).int32(message.matchType);
+        /* optional google.protobuf.FieldOptions set = 3; */
+        if (message.set)
+            FieldOptions$.internalBinaryWrite(message.set, writer.tag(3, 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 scalapb.FieldTransformation
+ */
+export const FieldTransformation = new FieldTransformation$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class PreprocessorOutput$Type extends MessageType {
+    constructor() {
+        super('scalapb.PreprocessorOutput', [
+            {
+                no: 1,
+                name: 'options_by_file',
+                kind: 'map',
+                K: 9 /*ScalarType.STRING*/,
+                V: { kind: 'message', T: () => ScalaPbOptions },
+            },
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create(this.messagePrototype);
+        message.optionsByFile = {};
+        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 /* map<string, scalapb.ScalaPbOptions> options_by_file */ 1:
+                    this.binaryReadMap1(message.optionsByFile, reader, 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;
+    }
+    binaryReadMap1(map, reader, options) {
+        let len = reader.uint32(), end = reader.pos + len, key, val;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case 1:
+                    key = reader.string();
+                    break;
+                case 2:
+                    val = ScalaPbOptions.internalBinaryRead(reader, reader.uint32(), options);
+                    break;
+                default:
+                    throw new globalThis.Error('unknown map entry field for scalapb.PreprocessorOutput.options_by_file');
+            }
+        }
+        map[key ?? ''] = val ?? ScalaPbOptions.create();
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* map<string, scalapb.ScalaPbOptions> options_by_file = 1; */
+        for (let k of globalThis.Object.keys(message.optionsByFile)) {
+            writer
+                .tag(1, WireType.LengthDelimited)
+                .fork()
+                .tag(1, WireType.LengthDelimited)
+                .string(k);
+            writer.tag(2, WireType.LengthDelimited).fork();
+            ScalaPbOptions.internalBinaryWrite(message.optionsByFile[k], writer, options);
+            writer.join().join();
+        }
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message scalapb.PreprocessorOutput
+ */
+export const PreprocessorOutput = new PreprocessorOutput$Type();