// Copyright 2024 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto

//go:build !protoopaque

package testeditions_hybrid

import (
	enums_hybrid "google.golang.org/protobuf/internal/testprotos/enums/enums_hybrid"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	_ "google.golang.org/protobuf/types/gofeaturespb"
	reflect "reflect"
	unsafe "unsafe"
)

type ForeignEnum int32

const (
	ForeignEnum_FOREIGN_ZERO ForeignEnum = 0
	ForeignEnum_FOREIGN_FOO  ForeignEnum = 4
	ForeignEnum_FOREIGN_BAR  ForeignEnum = 5
	ForeignEnum_FOREIGN_BAZ  ForeignEnum = 6
)

// Enum value maps for ForeignEnum.
var (
	ForeignEnum_name = map[int32]string{
		0: "FOREIGN_ZERO",
		4: "FOREIGN_FOO",
		5: "FOREIGN_BAR",
		6: "FOREIGN_BAZ",
	}
	ForeignEnum_value = map[string]int32{
		"FOREIGN_ZERO": 0,
		"FOREIGN_FOO":  4,
		"FOREIGN_BAR":  5,
		"FOREIGN_BAZ":  6,
	}
)

func (x ForeignEnum) Enum() *ForeignEnum {
	p := new(ForeignEnum)
	*p = x
	return p
}

func (x ForeignEnum) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (ForeignEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_enumTypes[0].Descriptor()
}

func (ForeignEnum) Type() protoreflect.EnumType {
	return &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_enumTypes[0]
}

func (x ForeignEnum) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

type TestAllTypes_NestedEnum int32

const (
	TestAllTypes_FOO TestAllTypes_NestedEnum = 0
	TestAllTypes_BAR TestAllTypes_NestedEnum = 1
	TestAllTypes_BAZ TestAllTypes_NestedEnum = 2
	TestAllTypes_NEG TestAllTypes_NestedEnum = -1 // Intentionally negative.
)

// Enum value maps for TestAllTypes_NestedEnum.
var (
	TestAllTypes_NestedEnum_name = map[int32]string{
		0:  "FOO",
		1:  "BAR",
		2:  "BAZ",
		-1: "NEG",
	}
	TestAllTypes_NestedEnum_value = map[string]int32{
		"FOO": 0,
		"BAR": 1,
		"BAZ": 2,
		"NEG": -1,
	}
)

func (x TestAllTypes_NestedEnum) Enum() *TestAllTypes_NestedEnum {
	p := new(TestAllTypes_NestedEnum)
	*p = x
	return p
}

func (x TestAllTypes_NestedEnum) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (TestAllTypes_NestedEnum) Descriptor() protoreflect.EnumDescriptor {
	return file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_enumTypes[1].Descriptor()
}

func (TestAllTypes_NestedEnum) Type() protoreflect.EnumType {
	return &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_enumTypes[1]
}

func (x TestAllTypes_NestedEnum) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

type TestAllTypes struct {
	state            protoimpl.MessageState `protogen:"hybrid.v1"`
	SingularInt32    int32                  `protobuf:"varint,124,opt,name=singular_int32,json=singularInt32" json:"singular_int32,omitempty"`
	SingularInt64    int64                  `protobuf:"varint,125,opt,name=singular_int64,json=singularInt64" json:"singular_int64,omitempty"`
	SingularUint32   uint32                 `protobuf:"varint,126,opt,name=singular_uint32,json=singularUint32" json:"singular_uint32,omitempty"`
	SingularUint64   uint64                 `protobuf:"varint,127,opt,name=singular_uint64,json=singularUint64" json:"singular_uint64,omitempty"`
	SingularSint32   int32                  `protobuf:"zigzag32,128,opt,name=singular_sint32,json=singularSint32" json:"singular_sint32,omitempty"`
	SingularSint64   int64                  `protobuf:"zigzag64,129,opt,name=singular_sint64,json=singularSint64" json:"singular_sint64,omitempty"`
	SingularFixed32  uint32                 `protobuf:"fixed32,130,opt,name=singular_fixed32,json=singularFixed32" json:"singular_fixed32,omitempty"`
	SingularFixed64  uint64                 `protobuf:"fixed64,131,opt,name=singular_fixed64,json=singularFixed64" json:"singular_fixed64,omitempty"`
	SingularSfixed32 int32                  `protobuf:"fixed32,132,opt,name=singular_sfixed32,json=singularSfixed32" json:"singular_sfixed32,omitempty"`
	SingularSfixed64 int64                  `protobuf:"fixed64,133,opt,name=singular_sfixed64,json=singularSfixed64" json:"singular_sfixed64,omitempty"`
	SingularFloat    float32                `protobuf:"fixed32,134,opt,name=singular_float,json=singularFloat" json:"singular_float,omitempty"`
	SingularDouble   float64                `protobuf:"fixed64,135,opt,name=singular_double,json=singularDouble" json:"singular_double,omitempty"`
	SingularBool     bool                   `protobuf:"varint,136,opt,name=singular_bool,json=singularBool" json:"singular_bool,omitempty"`
	SingularString   string                 `protobuf:"bytes,137,opt,name=singular_string,json=singularString" json:"singular_string,omitempty"`
	SingularBytes    []byte                 `protobuf:"bytes,138,opt,name=singular_bytes,json=singularBytes" json:"singular_bytes,omitempty"`
	// message-typed fields elided, as they cannot specify implicit presence.
	SingularNestedEnum        TestAllTypes_NestedEnum                `protobuf:"varint,142,opt,name=singular_nested_enum,json=singularNestedEnum,enum=hybrid.goproto.proto.testeditions.TestAllTypes_NestedEnum" json:"singular_nested_enum,omitempty"`
	SingularForeignEnum       ForeignEnum                            `protobuf:"varint,143,opt,name=singular_foreign_enum,json=singularForeignEnum,enum=hybrid.goproto.proto.testeditions.ForeignEnum" json:"singular_foreign_enum,omitempty"`
	SingularImportEnum        ImportEnum                             `protobuf:"varint,144,opt,name=singular_import_enum,json=singularImportEnum,enum=hybrid.goproto.proto.testeditions.ImportEnum" json:"singular_import_enum,omitempty"`
	OptionalInt32             *int32                                 `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32" json:"optional_int32,omitempty"`
	OptionalInt64             *int64                                 `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64" json:"optional_int64,omitempty"`
	OptionalUint32            *uint32                                `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32" json:"optional_uint32,omitempty"`
	OptionalUint64            *uint64                                `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64" json:"optional_uint64,omitempty"`
	OptionalSint32            *int32                                 `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32" json:"optional_sint32,omitempty"`
	OptionalSint64            *int64                                 `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64" json:"optional_sint64,omitempty"`
	OptionalFixed32           *uint32                                `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32" json:"optional_fixed32,omitempty"`
	OptionalFixed64           *uint64                                `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64" json:"optional_fixed64,omitempty"`
	OptionalSfixed32          *int32                                 `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32" json:"optional_sfixed32,omitempty"`
	OptionalSfixed64          *int64                                 `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64" json:"optional_sfixed64,omitempty"`
	OptionalFloat             *float32                               `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat" json:"optional_float,omitempty"`
	OptionalDouble            *float64                               `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble" json:"optional_double,omitempty"`
	OptionalBool              *bool                                  `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool" json:"optional_bool,omitempty"`
	OptionalString            *string                                `protobuf:"bytes,14,opt,name=optional_string,json=optionalString" json:"optional_string,omitempty"`
	OptionalBytes             []byte                                 `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes" json:"optional_bytes,omitempty"`
	Optionalgroup             *TestAllTypes_OptionalGroup            `protobuf:"group,16,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
	NotGroupLikeDelimited     *TestAllTypes_OptionalGroup            `protobuf:"group,17,opt,name=OptionalGroup,json=notGroupLikeDelimited" json:"not_group_like_delimited,omitempty"`
	OptionalNestedMessage     *TestAllTypes_NestedMessage            `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
	OptionalForeignMessage    *ForeignMessage                        `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage" json:"optional_foreign_message,omitempty"`
	OptionalImportMessage     *ImportMessage                         `protobuf:"bytes,20,opt,name=optional_import_message,json=optionalImportMessage" json:"optional_import_message,omitempty"`
	OptionalNestedEnum        *TestAllTypes_NestedEnum               `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,enum=hybrid.goproto.proto.testeditions.TestAllTypes_NestedEnum" json:"optional_nested_enum,omitempty"`
	OptionalForeignEnum       *ForeignEnum                           `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,enum=hybrid.goproto.proto.testeditions.ForeignEnum" json:"optional_foreign_enum,omitempty"`
	OptionalImportEnum        *ImportEnum                            `protobuf:"varint,23,opt,name=optional_import_enum,json=optionalImportEnum,enum=hybrid.goproto.proto.testeditions.ImportEnum" json:"optional_import_enum,omitempty"`
	OptionalLazyNestedMessage *TestAllTypes_NestedMessage            `protobuf:"bytes,24,opt,name=optional_lazy_nested_message,json=optionalLazyNestedMessage" json:"optional_lazy_nested_message,omitempty"`
	RepeatedInt32             []int32                                `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32" json:"repeated_int32,omitempty"`
	RepeatedInt64             []int64                                `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64" json:"repeated_int64,omitempty"`
	RepeatedUint32            []uint32                               `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32" json:"repeated_uint32,omitempty"`
	RepeatedUint64            []uint64                               `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64" json:"repeated_uint64,omitempty"`
	RepeatedSint32            []int32                                `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32" json:"repeated_sint32,omitempty"`
	RepeatedSint64            []int64                                `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64" json:"repeated_sint64,omitempty"`
	RepeatedFixed32           []uint32                               `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32" json:"repeated_fixed32,omitempty"`
	RepeatedFixed64           []uint64                               `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64" json:"repeated_fixed64,omitempty"`
	RepeatedSfixed32          []int32                                `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32" json:"repeated_sfixed32,omitempty"`
	RepeatedSfixed64          []int64                                `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64" json:"repeated_sfixed64,omitempty"`
	RepeatedFloat             []float32                              `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat" json:"repeated_float,omitempty"`
	RepeatedDouble            []float64                              `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble" json:"repeated_double,omitempty"`
	RepeatedBool              []bool                                 `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool" json:"repeated_bool,omitempty"`
	RepeatedString            []string                               `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString" json:"repeated_string,omitempty"`
	RepeatedBytes             [][]byte                               `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes" json:"repeated_bytes,omitempty"`
	Repeatedgroup             []*TestAllTypes_RepeatedGroup          `protobuf:"group,46,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
	RepeatedNestedMessage     []*TestAllTypes_NestedMessage          `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage" json:"repeated_nested_message,omitempty"`
	RepeatedForeignMessage    []*ForeignMessage                      `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage" json:"repeated_foreign_message,omitempty"`
	RepeatedImportmessage     []*ImportMessage                       `protobuf:"bytes,50,rep,name=repeated_importmessage,json=repeatedImportmessage" json:"repeated_importmessage,omitempty"`
	RepeatedNestedEnum        []TestAllTypes_NestedEnum              `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,enum=hybrid.goproto.proto.testeditions.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"`
	RepeatedForeignEnum       []ForeignEnum                          `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,enum=hybrid.goproto.proto.testeditions.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
	RepeatedImportenum        []ImportEnum                           `protobuf:"varint,53,rep,packed,name=repeated_importenum,json=repeatedImportenum,enum=hybrid.goproto.proto.testeditions.ImportEnum" json:"repeated_importenum,omitempty"`
	MapInt32Int32             map[int32]int32                        `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32" json:"map_int32_int32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	MapInt64Int64             map[int64]int64                        `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64" json:"map_int64_int64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	MapUint32Uint32           map[uint32]uint32                      `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32" json:"map_uint32_uint32,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	MapUint64Uint64           map[uint64]uint64                      `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64" json:"map_uint64_uint64,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	MapSint32Sint32           map[int32]int32                        `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32" json:"map_sint32_sint32,omitempty" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
	MapSint64Sint64           map[int64]int64                        `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64" json:"map_sint64_sint64,omitempty" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
	MapFixed32Fixed32         map[uint32]uint32                      `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32" json:"map_fixed32_fixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	MapFixed64Fixed64         map[uint64]uint64                      `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64" json:"map_fixed64_fixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	MapSfixed32Sfixed32       map[int32]int32                        `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32" json:"map_sfixed32_sfixed32,omitempty" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	MapSfixed64Sfixed64       map[int64]int64                        `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64" json:"map_sfixed64_sfixed64,omitempty" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	MapInt32Float             map[int32]float32                      `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float" json:"map_int32_float,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	MapInt32Double            map[int32]float64                      `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double" json:"map_int32_double,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	MapBoolBool               map[bool]bool                          `protobuf:"bytes,68,rep,name=map_bool_bool,json=mapBoolBool" json:"map_bool_bool,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	MapStringString           map[string]string                      `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString" json:"map_string_string,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	MapStringBytes            map[string][]byte                      `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes" json:"map_string_bytes,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	MapStringNestedMessage    map[string]*TestAllTypes_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage" json:"map_string_nested_message,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	MapStringNestedEnum       map[string]TestAllTypes_NestedEnum     `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=hybrid.goproto.proto.testeditions.TestAllTypes_NestedEnum"`
	// Singular with defaults
	DefaultInt32       *int32                   `protobuf:"varint,81,opt,name=default_int32,json=defaultInt32,def=81" json:"default_int32,omitempty"`
	DefaultInt64       *int64                   `protobuf:"varint,82,opt,name=default_int64,json=defaultInt64,def=82" json:"default_int64,omitempty"`
	DefaultUint32      *uint32                  `protobuf:"varint,83,opt,name=default_uint32,json=defaultUint32,def=83" json:"default_uint32,omitempty"`
	DefaultUint64      *uint64                  `protobuf:"varint,84,opt,name=default_uint64,json=defaultUint64,def=84" json:"default_uint64,omitempty"`
	DefaultSint32      *int32                   `protobuf:"zigzag32,85,opt,name=default_sint32,json=defaultSint32,def=-85" json:"default_sint32,omitempty"`
	DefaultSint64      *int64                   `protobuf:"zigzag64,86,opt,name=default_sint64,json=defaultSint64,def=86" json:"default_sint64,omitempty"`
	DefaultFixed32     *uint32                  `protobuf:"fixed32,87,opt,name=default_fixed32,json=defaultFixed32,def=87" json:"default_fixed32,omitempty"`
	DefaultFixed64     *uint64                  `protobuf:"fixed64,88,opt,name=default_fixed64,json=defaultFixed64,def=88" json:"default_fixed64,omitempty"`
	DefaultSfixed32    *int32                   `protobuf:"fixed32,89,opt,name=default_sfixed32,json=defaultSfixed32,def=89" json:"default_sfixed32,omitempty"`
	DefaultSfixed64    *int64                   `protobuf:"fixed64,80,opt,name=default_sfixed64,json=defaultSfixed64,def=-90" json:"default_sfixed64,omitempty"`
	DefaultFloat       *float32                 `protobuf:"fixed32,91,opt,name=default_float,json=defaultFloat,def=91.5" json:"default_float,omitempty"`
	DefaultDouble      *float64                 `protobuf:"fixed64,92,opt,name=default_double,json=defaultDouble,def=92000" json:"default_double,omitempty"`
	DefaultBool        *bool                    `protobuf:"varint,93,opt,name=default_bool,json=defaultBool,def=1" json:"default_bool,omitempty"`
	DefaultString      *string                  `protobuf:"bytes,94,opt,name=default_string,json=defaultString,def=hello" json:"default_string,omitempty"`
	DefaultBytes       []byte                   `protobuf:"bytes,95,opt,name=default_bytes,json=defaultBytes,def=world" json:"default_bytes,omitempty"`
	DefaultNestedEnum  *TestAllTypes_NestedEnum `protobuf:"varint,96,opt,name=default_nested_enum,json=defaultNestedEnum,enum=hybrid.goproto.proto.testeditions.TestAllTypes_NestedEnum,def=1" json:"default_nested_enum,omitempty"`
	DefaultForeignEnum *ForeignEnum             `protobuf:"varint,97,opt,name=default_foreign_enum,json=defaultForeignEnum,enum=hybrid.goproto.proto.testeditions.ForeignEnum,def=5" json:"default_foreign_enum,omitempty"`
	// Types that are valid to be assigned to OneofField:
	//
	//	*TestAllTypes_OneofUint32
	//	*TestAllTypes_OneofNestedMessage
	//	*TestAllTypes_OneofString
	//	*TestAllTypes_OneofBytes
	//	*TestAllTypes_OneofBool
	//	*TestAllTypes_OneofUint64
	//	*TestAllTypes_OneofFloat
	//	*TestAllTypes_OneofDouble
	//	*TestAllTypes_OneofEnum
	//	*TestAllTypes_Oneofgroup
	OneofField isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"`
	// A oneof with exactly one field.
	//
	// Types that are valid to be assigned to OneofOptional:
	//
	//	*TestAllTypes_OneofOptionalUint32
	OneofOptional isTestAllTypes_OneofOptional `protobuf_oneof:"oneof_optional"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

// Default values for TestAllTypes fields.
const (
	Default_TestAllTypes_DefaultInt32       = int32(81)
	Default_TestAllTypes_DefaultInt64       = int64(82)
	Default_TestAllTypes_DefaultUint32      = uint32(83)
	Default_TestAllTypes_DefaultUint64      = uint64(84)
	Default_TestAllTypes_DefaultSint32      = int32(-85)
	Default_TestAllTypes_DefaultSint64      = int64(86)
	Default_TestAllTypes_DefaultFixed32     = uint32(87)
	Default_TestAllTypes_DefaultFixed64     = uint64(88)
	Default_TestAllTypes_DefaultSfixed32    = int32(89)
	Default_TestAllTypes_DefaultSfixed64    = int64(-90)
	Default_TestAllTypes_DefaultFloat       = float32(91.5)
	Default_TestAllTypes_DefaultDouble      = float64(92000)
	Default_TestAllTypes_DefaultBool        = bool(true)
	Default_TestAllTypes_DefaultString      = string("hello")
	Default_TestAllTypes_DefaultNestedEnum  = TestAllTypes_BAR
	Default_TestAllTypes_DefaultForeignEnum = ForeignEnum_FOREIGN_BAR
)

// Default values for TestAllTypes fields.
var (
	Default_TestAllTypes_DefaultBytes = []byte("world")
)

func (x *TestAllTypes) Reset() {
	*x = TestAllTypes{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestAllTypes) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestAllTypes) ProtoMessage() {}

func (x *TestAllTypes) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestAllTypes) GetSingularInt32() int32 {
	if x != nil {
		return x.SingularInt32
	}
	return 0
}

func (x *TestAllTypes) GetSingularInt64() int64 {
	if x != nil {
		return x.SingularInt64
	}
	return 0
}

func (x *TestAllTypes) GetSingularUint32() uint32 {
	if x != nil {
		return x.SingularUint32
	}
	return 0
}

func (x *TestAllTypes) GetSingularUint64() uint64 {
	if x != nil {
		return x.SingularUint64
	}
	return 0
}

func (x *TestAllTypes) GetSingularSint32() int32 {
	if x != nil {
		return x.SingularSint32
	}
	return 0
}

func (x *TestAllTypes) GetSingularSint64() int64 {
	if x != nil {
		return x.SingularSint64
	}
	return 0
}

func (x *TestAllTypes) GetSingularFixed32() uint32 {
	if x != nil {
		return x.SingularFixed32
	}
	return 0
}

func (x *TestAllTypes) GetSingularFixed64() uint64 {
	if x != nil {
		return x.SingularFixed64
	}
	return 0
}

func (x *TestAllTypes) GetSingularSfixed32() int32 {
	if x != nil {
		return x.SingularSfixed32
	}
	return 0
}

func (x *TestAllTypes) GetSingularSfixed64() int64 {
	if x != nil {
		return x.SingularSfixed64
	}
	return 0
}

func (x *TestAllTypes) GetSingularFloat() float32 {
	if x != nil {
		return x.SingularFloat
	}
	return 0
}

func (x *TestAllTypes) GetSingularDouble() float64 {
	if x != nil {
		return x.SingularDouble
	}
	return 0
}

func (x *TestAllTypes) GetSingularBool() bool {
	if x != nil {
		return x.SingularBool
	}
	return false
}

func (x *TestAllTypes) GetSingularString() string {
	if x != nil {
		return x.SingularString
	}
	return ""
}

func (x *TestAllTypes) GetSingularBytes() []byte {
	if x != nil {
		return x.SingularBytes
	}
	return nil
}

func (x *TestAllTypes) GetSingularNestedEnum() TestAllTypes_NestedEnum {
	if x != nil {
		return x.SingularNestedEnum
	}
	return TestAllTypes_FOO
}

func (x *TestAllTypes) GetSingularForeignEnum() ForeignEnum {
	if x != nil {
		return x.SingularForeignEnum
	}
	return ForeignEnum_FOREIGN_ZERO
}

func (x *TestAllTypes) GetSingularImportEnum() ImportEnum {
	if x != nil {
		return x.SingularImportEnum
	}
	return ImportEnum_IMPORT_ZERO
}

func (x *TestAllTypes) GetOptionalInt32() int32 {
	if x != nil && x.OptionalInt32 != nil {
		return *x.OptionalInt32
	}
	return 0
}

func (x *TestAllTypes) GetOptionalInt64() int64 {
	if x != nil && x.OptionalInt64 != nil {
		return *x.OptionalInt64
	}
	return 0
}

func (x *TestAllTypes) GetOptionalUint32() uint32 {
	if x != nil && x.OptionalUint32 != nil {
		return *x.OptionalUint32
	}
	return 0
}

func (x *TestAllTypes) GetOptionalUint64() uint64 {
	if x != nil && x.OptionalUint64 != nil {
		return *x.OptionalUint64
	}
	return 0
}

func (x *TestAllTypes) GetOptionalSint32() int32 {
	if x != nil && x.OptionalSint32 != nil {
		return *x.OptionalSint32
	}
	return 0
}

func (x *TestAllTypes) GetOptionalSint64() int64 {
	if x != nil && x.OptionalSint64 != nil {
		return *x.OptionalSint64
	}
	return 0
}

func (x *TestAllTypes) GetOptionalFixed32() uint32 {
	if x != nil && x.OptionalFixed32 != nil {
		return *x.OptionalFixed32
	}
	return 0
}

func (x *TestAllTypes) GetOptionalFixed64() uint64 {
	if x != nil && x.OptionalFixed64 != nil {
		return *x.OptionalFixed64
	}
	return 0
}

func (x *TestAllTypes) GetOptionalSfixed32() int32 {
	if x != nil && x.OptionalSfixed32 != nil {
		return *x.OptionalSfixed32
	}
	return 0
}

func (x *TestAllTypes) GetOptionalSfixed64() int64 {
	if x != nil && x.OptionalSfixed64 != nil {
		return *x.OptionalSfixed64
	}
	return 0
}

func (x *TestAllTypes) GetOptionalFloat() float32 {
	if x != nil && x.OptionalFloat != nil {
		return *x.OptionalFloat
	}
	return 0
}

func (x *TestAllTypes) GetOptionalDouble() float64 {
	if x != nil && x.OptionalDouble != nil {
		return *x.OptionalDouble
	}
	return 0
}

func (x *TestAllTypes) GetOptionalBool() bool {
	if x != nil && x.OptionalBool != nil {
		return *x.OptionalBool
	}
	return false
}

func (x *TestAllTypes) GetOptionalString() string {
	if x != nil && x.OptionalString != nil {
		return *x.OptionalString
	}
	return ""
}

func (x *TestAllTypes) GetOptionalBytes() []byte {
	if x != nil {
		return x.OptionalBytes
	}
	return nil
}

func (x *TestAllTypes) GetOptionalgroup() *TestAllTypes_OptionalGroup {
	if x != nil {
		return x.Optionalgroup
	}
	return nil
}

func (x *TestAllTypes) GetNotGroupLikeDelimited() *TestAllTypes_OptionalGroup {
	if x != nil {
		return x.NotGroupLikeDelimited
	}
	return nil
}

func (x *TestAllTypes) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
	if x != nil {
		return x.OptionalNestedMessage
	}
	return nil
}

func (x *TestAllTypes) GetOptionalForeignMessage() *ForeignMessage {
	if x != nil {
		return x.OptionalForeignMessage
	}
	return nil
}

func (x *TestAllTypes) GetOptionalImportMessage() *ImportMessage {
	if x != nil {
		return x.OptionalImportMessage
	}
	return nil
}

func (x *TestAllTypes) GetOptionalNestedEnum() TestAllTypes_NestedEnum {
	if x != nil && x.OptionalNestedEnum != nil {
		return *x.OptionalNestedEnum
	}
	return TestAllTypes_FOO
}

func (x *TestAllTypes) GetOptionalForeignEnum() ForeignEnum {
	if x != nil && x.OptionalForeignEnum != nil {
		return *x.OptionalForeignEnum
	}
	return ForeignEnum_FOREIGN_ZERO
}

func (x *TestAllTypes) GetOptionalImportEnum() ImportEnum {
	if x != nil && x.OptionalImportEnum != nil {
		return *x.OptionalImportEnum
	}
	return ImportEnum_IMPORT_ZERO
}

func (x *TestAllTypes) GetOptionalLazyNestedMessage() *TestAllTypes_NestedMessage {
	if x != nil {
		return x.OptionalLazyNestedMessage
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedInt32() []int32 {
	if x != nil {
		return x.RepeatedInt32
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedInt64() []int64 {
	if x != nil {
		return x.RepeatedInt64
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedUint32() []uint32 {
	if x != nil {
		return x.RepeatedUint32
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedUint64() []uint64 {
	if x != nil {
		return x.RepeatedUint64
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedSint32() []int32 {
	if x != nil {
		return x.RepeatedSint32
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedSint64() []int64 {
	if x != nil {
		return x.RepeatedSint64
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedFixed32() []uint32 {
	if x != nil {
		return x.RepeatedFixed32
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedFixed64() []uint64 {
	if x != nil {
		return x.RepeatedFixed64
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedSfixed32() []int32 {
	if x != nil {
		return x.RepeatedSfixed32
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedSfixed64() []int64 {
	if x != nil {
		return x.RepeatedSfixed64
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedFloat() []float32 {
	if x != nil {
		return x.RepeatedFloat
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedDouble() []float64 {
	if x != nil {
		return x.RepeatedDouble
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedBool() []bool {
	if x != nil {
		return x.RepeatedBool
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedString() []string {
	if x != nil {
		return x.RepeatedString
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedBytes() [][]byte {
	if x != nil {
		return x.RepeatedBytes
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedgroup() []*TestAllTypes_RepeatedGroup {
	if x != nil {
		return x.Repeatedgroup
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedNestedMessage() []*TestAllTypes_NestedMessage {
	if x != nil {
		return x.RepeatedNestedMessage
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedForeignMessage() []*ForeignMessage {
	if x != nil {
		return x.RepeatedForeignMessage
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedImportmessage() []*ImportMessage {
	if x != nil {
		return x.RepeatedImportmessage
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedNestedEnum() []TestAllTypes_NestedEnum {
	if x != nil {
		return x.RepeatedNestedEnum
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedForeignEnum() []ForeignEnum {
	if x != nil {
		return x.RepeatedForeignEnum
	}
	return nil
}

func (x *TestAllTypes) GetRepeatedImportenum() []ImportEnum {
	if x != nil {
		return x.RepeatedImportenum
	}
	return nil
}

func (x *TestAllTypes) GetMapInt32Int32() map[int32]int32 {
	if x != nil {
		return x.MapInt32Int32
	}
	return nil
}

func (x *TestAllTypes) GetMapInt64Int64() map[int64]int64 {
	if x != nil {
		return x.MapInt64Int64
	}
	return nil
}

func (x *TestAllTypes) GetMapUint32Uint32() map[uint32]uint32 {
	if x != nil {
		return x.MapUint32Uint32
	}
	return nil
}

func (x *TestAllTypes) GetMapUint64Uint64() map[uint64]uint64 {
	if x != nil {
		return x.MapUint64Uint64
	}
	return nil
}

func (x *TestAllTypes) GetMapSint32Sint32() map[int32]int32 {
	if x != nil {
		return x.MapSint32Sint32
	}
	return nil
}

func (x *TestAllTypes) GetMapSint64Sint64() map[int64]int64 {
	if x != nil {
		return x.MapSint64Sint64
	}
	return nil
}

func (x *TestAllTypes) GetMapFixed32Fixed32() map[uint32]uint32 {
	if x != nil {
		return x.MapFixed32Fixed32
	}
	return nil
}

func (x *TestAllTypes) GetMapFixed64Fixed64() map[uint64]uint64 {
	if x != nil {
		return x.MapFixed64Fixed64
	}
	return nil
}

func (x *TestAllTypes) GetMapSfixed32Sfixed32() map[int32]int32 {
	if x != nil {
		return x.MapSfixed32Sfixed32
	}
	return nil
}

func (x *TestAllTypes) GetMapSfixed64Sfixed64() map[int64]int64 {
	if x != nil {
		return x.MapSfixed64Sfixed64
	}
	return nil
}

func (x *TestAllTypes) GetMapInt32Float() map[int32]float32 {
	if x != nil {
		return x.MapInt32Float
	}
	return nil
}

func (x *TestAllTypes) GetMapInt32Double() map[int32]float64 {
	if x != nil {
		return x.MapInt32Double
	}
	return nil
}

func (x *TestAllTypes) GetMapBoolBool() map[bool]bool {
	if x != nil {
		return x.MapBoolBool
	}
	return nil
}

func (x *TestAllTypes) GetMapStringString() map[string]string {
	if x != nil {
		return x.MapStringString
	}
	return nil
}

func (x *TestAllTypes) GetMapStringBytes() map[string][]byte {
	if x != nil {
		return x.MapStringBytes
	}
	return nil
}

func (x *TestAllTypes) GetMapStringNestedMessage() map[string]*TestAllTypes_NestedMessage {
	if x != nil {
		return x.MapStringNestedMessage
	}
	return nil
}

func (x *TestAllTypes) GetMapStringNestedEnum() map[string]TestAllTypes_NestedEnum {
	if x != nil {
		return x.MapStringNestedEnum
	}
	return nil
}

func (x *TestAllTypes) GetDefaultInt32() int32 {
	if x != nil && x.DefaultInt32 != nil {
		return *x.DefaultInt32
	}
	return Default_TestAllTypes_DefaultInt32
}

func (x *TestAllTypes) GetDefaultInt64() int64 {
	if x != nil && x.DefaultInt64 != nil {
		return *x.DefaultInt64
	}
	return Default_TestAllTypes_DefaultInt64
}

func (x *TestAllTypes) GetDefaultUint32() uint32 {
	if x != nil && x.DefaultUint32 != nil {
		return *x.DefaultUint32
	}
	return Default_TestAllTypes_DefaultUint32
}

func (x *TestAllTypes) GetDefaultUint64() uint64 {
	if x != nil && x.DefaultUint64 != nil {
		return *x.DefaultUint64
	}
	return Default_TestAllTypes_DefaultUint64
}

func (x *TestAllTypes) GetDefaultSint32() int32 {
	if x != nil && x.DefaultSint32 != nil {
		return *x.DefaultSint32
	}
	return Default_TestAllTypes_DefaultSint32
}

func (x *TestAllTypes) GetDefaultSint64() int64 {
	if x != nil && x.DefaultSint64 != nil {
		return *x.DefaultSint64
	}
	return Default_TestAllTypes_DefaultSint64
}

func (x *TestAllTypes) GetDefaultFixed32() uint32 {
	if x != nil && x.DefaultFixed32 != nil {
		return *x.DefaultFixed32
	}
	return Default_TestAllTypes_DefaultFixed32
}

func (x *TestAllTypes) GetDefaultFixed64() uint64 {
	if x != nil && x.DefaultFixed64 != nil {
		return *x.DefaultFixed64
	}
	return Default_TestAllTypes_DefaultFixed64
}

func (x *TestAllTypes) GetDefaultSfixed32() int32 {
	if x != nil && x.DefaultSfixed32 != nil {
		return *x.DefaultSfixed32
	}
	return Default_TestAllTypes_DefaultSfixed32
}

func (x *TestAllTypes) GetDefaultSfixed64() int64 {
	if x != nil && x.DefaultSfixed64 != nil {
		return *x.DefaultSfixed64
	}
	return Default_TestAllTypes_DefaultSfixed64
}

func (x *TestAllTypes) GetDefaultFloat() float32 {
	if x != nil && x.DefaultFloat != nil {
		return *x.DefaultFloat
	}
	return Default_TestAllTypes_DefaultFloat
}

func (x *TestAllTypes) GetDefaultDouble() float64 {
	if x != nil && x.DefaultDouble != nil {
		return *x.DefaultDouble
	}
	return Default_TestAllTypes_DefaultDouble
}

func (x *TestAllTypes) GetDefaultBool() bool {
	if x != nil && x.DefaultBool != nil {
		return *x.DefaultBool
	}
	return Default_TestAllTypes_DefaultBool
}

func (x *TestAllTypes) GetDefaultString() string {
	if x != nil && x.DefaultString != nil {
		return *x.DefaultString
	}
	return Default_TestAllTypes_DefaultString
}

func (x *TestAllTypes) GetDefaultBytes() []byte {
	if x != nil && x.DefaultBytes != nil {
		return x.DefaultBytes
	}
	return append([]byte(nil), Default_TestAllTypes_DefaultBytes...)
}

func (x *TestAllTypes) GetDefaultNestedEnum() TestAllTypes_NestedEnum {
	if x != nil && x.DefaultNestedEnum != nil {
		return *x.DefaultNestedEnum
	}
	return Default_TestAllTypes_DefaultNestedEnum
}

func (x *TestAllTypes) GetDefaultForeignEnum() ForeignEnum {
	if x != nil && x.DefaultForeignEnum != nil {
		return *x.DefaultForeignEnum
	}
	return Default_TestAllTypes_DefaultForeignEnum
}

func (x *TestAllTypes) GetOneofField() isTestAllTypes_OneofField {
	if x != nil {
		return x.OneofField
	}
	return nil
}

func (x *TestAllTypes) GetOneofUint32() uint32 {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofUint32); ok {
			return x.OneofUint32
		}
	}
	return 0
}

func (x *TestAllTypes) GetOneofNestedMessage() *TestAllTypes_NestedMessage {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofNestedMessage); ok {
			return x.OneofNestedMessage
		}
	}
	return nil
}

func (x *TestAllTypes) GetOneofString() string {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofString); ok {
			return x.OneofString
		}
	}
	return ""
}

func (x *TestAllTypes) GetOneofBytes() []byte {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofBytes); ok {
			return x.OneofBytes
		}
	}
	return nil
}

func (x *TestAllTypes) GetOneofBool() bool {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofBool); ok {
			return x.OneofBool
		}
	}
	return false
}

func (x *TestAllTypes) GetOneofUint64() uint64 {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofUint64); ok {
			return x.OneofUint64
		}
	}
	return 0
}

func (x *TestAllTypes) GetOneofFloat() float32 {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofFloat); ok {
			return x.OneofFloat
		}
	}
	return 0
}

func (x *TestAllTypes) GetOneofDouble() float64 {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofDouble); ok {
			return x.OneofDouble
		}
	}
	return 0
}

func (x *TestAllTypes) GetOneofEnum() TestAllTypes_NestedEnum {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_OneofEnum); ok {
			return x.OneofEnum
		}
	}
	return TestAllTypes_FOO
}

func (x *TestAllTypes) GetOneofgroup() *TestAllTypes_OneofGroup {
	if x != nil {
		if x, ok := x.OneofField.(*TestAllTypes_Oneofgroup); ok {
			return x.Oneofgroup
		}
	}
	return nil
}

func (x *TestAllTypes) GetOneofOptional() isTestAllTypes_OneofOptional {
	if x != nil {
		return x.OneofOptional
	}
	return nil
}

func (x *TestAllTypes) GetOneofOptionalUint32() uint32 {
	if x != nil {
		if x, ok := x.OneofOptional.(*TestAllTypes_OneofOptionalUint32); ok {
			return x.OneofOptionalUint32
		}
	}
	return 0
}

func (x *TestAllTypes) SetSingularInt32(v int32) {
	x.SingularInt32 = v
}

func (x *TestAllTypes) SetSingularInt64(v int64) {
	x.SingularInt64 = v
}

func (x *TestAllTypes) SetSingularUint32(v uint32) {
	x.SingularUint32 = v
}

func (x *TestAllTypes) SetSingularUint64(v uint64) {
	x.SingularUint64 = v
}

func (x *TestAllTypes) SetSingularSint32(v int32) {
	x.SingularSint32 = v
}

func (x *TestAllTypes) SetSingularSint64(v int64) {
	x.SingularSint64 = v
}

func (x *TestAllTypes) SetSingularFixed32(v uint32) {
	x.SingularFixed32 = v
}

func (x *TestAllTypes) SetSingularFixed64(v uint64) {
	x.SingularFixed64 = v
}

func (x *TestAllTypes) SetSingularSfixed32(v int32) {
	x.SingularSfixed32 = v
}

func (x *TestAllTypes) SetSingularSfixed64(v int64) {
	x.SingularSfixed64 = v
}

func (x *TestAllTypes) SetSingularFloat(v float32) {
	x.SingularFloat = v
}

func (x *TestAllTypes) SetSingularDouble(v float64) {
	x.SingularDouble = v
}

func (x *TestAllTypes) SetSingularBool(v bool) {
	x.SingularBool = v
}

func (x *TestAllTypes) SetSingularString(v string) {
	x.SingularString = v
}

func (x *TestAllTypes) SetSingularBytes(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.SingularBytes = v
}

func (x *TestAllTypes) SetSingularNestedEnum(v TestAllTypes_NestedEnum) {
	x.SingularNestedEnum = v
}

func (x *TestAllTypes) SetSingularForeignEnum(v ForeignEnum) {
	x.SingularForeignEnum = v
}

func (x *TestAllTypes) SetSingularImportEnum(v ImportEnum) {
	x.SingularImportEnum = v
}

func (x *TestAllTypes) SetOptionalInt32(v int32) {
	x.OptionalInt32 = &v
}

func (x *TestAllTypes) SetOptionalInt64(v int64) {
	x.OptionalInt64 = &v
}

func (x *TestAllTypes) SetOptionalUint32(v uint32) {
	x.OptionalUint32 = &v
}

func (x *TestAllTypes) SetOptionalUint64(v uint64) {
	x.OptionalUint64 = &v
}

func (x *TestAllTypes) SetOptionalSint32(v int32) {
	x.OptionalSint32 = &v
}

func (x *TestAllTypes) SetOptionalSint64(v int64) {
	x.OptionalSint64 = &v
}

func (x *TestAllTypes) SetOptionalFixed32(v uint32) {
	x.OptionalFixed32 = &v
}

func (x *TestAllTypes) SetOptionalFixed64(v uint64) {
	x.OptionalFixed64 = &v
}

func (x *TestAllTypes) SetOptionalSfixed32(v int32) {
	x.OptionalSfixed32 = &v
}

func (x *TestAllTypes) SetOptionalSfixed64(v int64) {
	x.OptionalSfixed64 = &v
}

func (x *TestAllTypes) SetOptionalFloat(v float32) {
	x.OptionalFloat = &v
}

func (x *TestAllTypes) SetOptionalDouble(v float64) {
	x.OptionalDouble = &v
}

func (x *TestAllTypes) SetOptionalBool(v bool) {
	x.OptionalBool = &v
}

func (x *TestAllTypes) SetOptionalString(v string) {
	x.OptionalString = &v
}

func (x *TestAllTypes) SetOptionalBytes(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.OptionalBytes = v
}

func (x *TestAllTypes) SetOptionalgroup(v *TestAllTypes_OptionalGroup) {
	x.Optionalgroup = v
}

func (x *TestAllTypes) SetNotGroupLikeDelimited(v *TestAllTypes_OptionalGroup) {
	x.NotGroupLikeDelimited = v
}

func (x *TestAllTypes) SetOptionalNestedMessage(v *TestAllTypes_NestedMessage) {
	x.OptionalNestedMessage = v
}

func (x *TestAllTypes) SetOptionalForeignMessage(v *ForeignMessage) {
	x.OptionalForeignMessage = v
}

func (x *TestAllTypes) SetOptionalImportMessage(v *ImportMessage) {
	x.OptionalImportMessage = v
}

func (x *TestAllTypes) SetOptionalNestedEnum(v TestAllTypes_NestedEnum) {
	x.OptionalNestedEnum = &v
}

func (x *TestAllTypes) SetOptionalForeignEnum(v ForeignEnum) {
	x.OptionalForeignEnum = &v
}

func (x *TestAllTypes) SetOptionalImportEnum(v ImportEnum) {
	x.OptionalImportEnum = &v
}

func (x *TestAllTypes) SetOptionalLazyNestedMessage(v *TestAllTypes_NestedMessage) {
	x.OptionalLazyNestedMessage = v
}

func (x *TestAllTypes) SetRepeatedInt32(v []int32) {
	x.RepeatedInt32 = v
}

func (x *TestAllTypes) SetRepeatedInt64(v []int64) {
	x.RepeatedInt64 = v
}

func (x *TestAllTypes) SetRepeatedUint32(v []uint32) {
	x.RepeatedUint32 = v
}

func (x *TestAllTypes) SetRepeatedUint64(v []uint64) {
	x.RepeatedUint64 = v
}

func (x *TestAllTypes) SetRepeatedSint32(v []int32) {
	x.RepeatedSint32 = v
}

func (x *TestAllTypes) SetRepeatedSint64(v []int64) {
	x.RepeatedSint64 = v
}

func (x *TestAllTypes) SetRepeatedFixed32(v []uint32) {
	x.RepeatedFixed32 = v
}

func (x *TestAllTypes) SetRepeatedFixed64(v []uint64) {
	x.RepeatedFixed64 = v
}

func (x *TestAllTypes) SetRepeatedSfixed32(v []int32) {
	x.RepeatedSfixed32 = v
}

func (x *TestAllTypes) SetRepeatedSfixed64(v []int64) {
	x.RepeatedSfixed64 = v
}

func (x *TestAllTypes) SetRepeatedFloat(v []float32) {
	x.RepeatedFloat = v
}

func (x *TestAllTypes) SetRepeatedDouble(v []float64) {
	x.RepeatedDouble = v
}

func (x *TestAllTypes) SetRepeatedBool(v []bool) {
	x.RepeatedBool = v
}

func (x *TestAllTypes) SetRepeatedString(v []string) {
	x.RepeatedString = v
}

func (x *TestAllTypes) SetRepeatedBytes(v [][]byte) {
	x.RepeatedBytes = v
}

func (x *TestAllTypes) SetRepeatedgroup(v []*TestAllTypes_RepeatedGroup) {
	x.Repeatedgroup = v
}

func (x *TestAllTypes) SetRepeatedNestedMessage(v []*TestAllTypes_NestedMessage) {
	x.RepeatedNestedMessage = v
}

func (x *TestAllTypes) SetRepeatedForeignMessage(v []*ForeignMessage) {
	x.RepeatedForeignMessage = v
}

func (x *TestAllTypes) SetRepeatedImportmessage(v []*ImportMessage) {
	x.RepeatedImportmessage = v
}

func (x *TestAllTypes) SetRepeatedNestedEnum(v []TestAllTypes_NestedEnum) {
	x.RepeatedNestedEnum = v
}

func (x *TestAllTypes) SetRepeatedForeignEnum(v []ForeignEnum) {
	x.RepeatedForeignEnum = v
}

func (x *TestAllTypes) SetRepeatedImportenum(v []ImportEnum) {
	x.RepeatedImportenum = v
}

func (x *TestAllTypes) SetMapInt32Int32(v map[int32]int32) {
	x.MapInt32Int32 = v
}

func (x *TestAllTypes) SetMapInt64Int64(v map[int64]int64) {
	x.MapInt64Int64 = v
}

func (x *TestAllTypes) SetMapUint32Uint32(v map[uint32]uint32) {
	x.MapUint32Uint32 = v
}

func (x *TestAllTypes) SetMapUint64Uint64(v map[uint64]uint64) {
	x.MapUint64Uint64 = v
}

func (x *TestAllTypes) SetMapSint32Sint32(v map[int32]int32) {
	x.MapSint32Sint32 = v
}

func (x *TestAllTypes) SetMapSint64Sint64(v map[int64]int64) {
	x.MapSint64Sint64 = v
}

func (x *TestAllTypes) SetMapFixed32Fixed32(v map[uint32]uint32) {
	x.MapFixed32Fixed32 = v
}

func (x *TestAllTypes) SetMapFixed64Fixed64(v map[uint64]uint64) {
	x.MapFixed64Fixed64 = v
}

func (x *TestAllTypes) SetMapSfixed32Sfixed32(v map[int32]int32) {
	x.MapSfixed32Sfixed32 = v
}

func (x *TestAllTypes) SetMapSfixed64Sfixed64(v map[int64]int64) {
	x.MapSfixed64Sfixed64 = v
}

func (x *TestAllTypes) SetMapInt32Float(v map[int32]float32) {
	x.MapInt32Float = v
}

func (x *TestAllTypes) SetMapInt32Double(v map[int32]float64) {
	x.MapInt32Double = v
}

func (x *TestAllTypes) SetMapBoolBool(v map[bool]bool) {
	x.MapBoolBool = v
}

func (x *TestAllTypes) SetMapStringString(v map[string]string) {
	x.MapStringString = v
}

func (x *TestAllTypes) SetMapStringBytes(v map[string][]byte) {
	x.MapStringBytes = v
}

func (x *TestAllTypes) SetMapStringNestedMessage(v map[string]*TestAllTypes_NestedMessage) {
	x.MapStringNestedMessage = v
}

func (x *TestAllTypes) SetMapStringNestedEnum(v map[string]TestAllTypes_NestedEnum) {
	x.MapStringNestedEnum = v
}

func (x *TestAllTypes) SetDefaultInt32(v int32) {
	x.DefaultInt32 = &v
}

func (x *TestAllTypes) SetDefaultInt64(v int64) {
	x.DefaultInt64 = &v
}

func (x *TestAllTypes) SetDefaultUint32(v uint32) {
	x.DefaultUint32 = &v
}

func (x *TestAllTypes) SetDefaultUint64(v uint64) {
	x.DefaultUint64 = &v
}

func (x *TestAllTypes) SetDefaultSint32(v int32) {
	x.DefaultSint32 = &v
}

func (x *TestAllTypes) SetDefaultSint64(v int64) {
	x.DefaultSint64 = &v
}

func (x *TestAllTypes) SetDefaultFixed32(v uint32) {
	x.DefaultFixed32 = &v
}

func (x *TestAllTypes) SetDefaultFixed64(v uint64) {
	x.DefaultFixed64 = &v
}

func (x *TestAllTypes) SetDefaultSfixed32(v int32) {
	x.DefaultSfixed32 = &v
}

func (x *TestAllTypes) SetDefaultSfixed64(v int64) {
	x.DefaultSfixed64 = &v
}

func (x *TestAllTypes) SetDefaultFloat(v float32) {
	x.DefaultFloat = &v
}

func (x *TestAllTypes) SetDefaultDouble(v float64) {
	x.DefaultDouble = &v
}

func (x *TestAllTypes) SetDefaultBool(v bool) {
	x.DefaultBool = &v
}

func (x *TestAllTypes) SetDefaultString(v string) {
	x.DefaultString = &v
}

func (x *TestAllTypes) SetDefaultBytes(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.DefaultBytes = v
}

func (x *TestAllTypes) SetDefaultNestedEnum(v TestAllTypes_NestedEnum) {
	x.DefaultNestedEnum = &v
}

func (x *TestAllTypes) SetDefaultForeignEnum(v ForeignEnum) {
	x.DefaultForeignEnum = &v
}

func (x *TestAllTypes) SetOneofUint32(v uint32) {
	x.OneofField = &TestAllTypes_OneofUint32{v}
}

func (x *TestAllTypes) SetOneofNestedMessage(v *TestAllTypes_NestedMessage) {
	if v == nil {
		x.OneofField = nil
		return
	}
	x.OneofField = &TestAllTypes_OneofNestedMessage{v}
}

func (x *TestAllTypes) SetOneofString(v string) {
	x.OneofField = &TestAllTypes_OneofString{v}
}

func (x *TestAllTypes) SetOneofBytes(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.OneofField = &TestAllTypes_OneofBytes{v}
}

func (x *TestAllTypes) SetOneofBool(v bool) {
	x.OneofField = &TestAllTypes_OneofBool{v}
}

func (x *TestAllTypes) SetOneofUint64(v uint64) {
	x.OneofField = &TestAllTypes_OneofUint64{v}
}

func (x *TestAllTypes) SetOneofFloat(v float32) {
	x.OneofField = &TestAllTypes_OneofFloat{v}
}

func (x *TestAllTypes) SetOneofDouble(v float64) {
	x.OneofField = &TestAllTypes_OneofDouble{v}
}

func (x *TestAllTypes) SetOneofEnum(v TestAllTypes_NestedEnum) {
	x.OneofField = &TestAllTypes_OneofEnum{v}
}

func (x *TestAllTypes) SetOneofgroup(v *TestAllTypes_OneofGroup) {
	if v == nil {
		x.OneofField = nil
		return
	}
	x.OneofField = &TestAllTypes_Oneofgroup{v}
}

func (x *TestAllTypes) SetOneofOptionalUint32(v uint32) {
	x.OneofOptional = &TestAllTypes_OneofOptionalUint32{v}
}

func (x *TestAllTypes) HasOptionalInt32() bool {
	if x == nil {
		return false
	}
	return x.OptionalInt32 != nil
}

func (x *TestAllTypes) HasOptionalInt64() bool {
	if x == nil {
		return false
	}
	return x.OptionalInt64 != nil
}

func (x *TestAllTypes) HasOptionalUint32() bool {
	if x == nil {
		return false
	}
	return x.OptionalUint32 != nil
}

func (x *TestAllTypes) HasOptionalUint64() bool {
	if x == nil {
		return false
	}
	return x.OptionalUint64 != nil
}

func (x *TestAllTypes) HasOptionalSint32() bool {
	if x == nil {
		return false
	}
	return x.OptionalSint32 != nil
}

func (x *TestAllTypes) HasOptionalSint64() bool {
	if x == nil {
		return false
	}
	return x.OptionalSint64 != nil
}

func (x *TestAllTypes) HasOptionalFixed32() bool {
	if x == nil {
		return false
	}
	return x.OptionalFixed32 != nil
}

func (x *TestAllTypes) HasOptionalFixed64() bool {
	if x == nil {
		return false
	}
	return x.OptionalFixed64 != nil
}

func (x *TestAllTypes) HasOptionalSfixed32() bool {
	if x == nil {
		return false
	}
	return x.OptionalSfixed32 != nil
}

func (x *TestAllTypes) HasOptionalSfixed64() bool {
	if x == nil {
		return false
	}
	return x.OptionalSfixed64 != nil
}

func (x *TestAllTypes) HasOptionalFloat() bool {
	if x == nil {
		return false
	}
	return x.OptionalFloat != nil
}

func (x *TestAllTypes) HasOptionalDouble() bool {
	if x == nil {
		return false
	}
	return x.OptionalDouble != nil
}

func (x *TestAllTypes) HasOptionalBool() bool {
	if x == nil {
		return false
	}
	return x.OptionalBool != nil
}

func (x *TestAllTypes) HasOptionalString() bool {
	if x == nil {
		return false
	}
	return x.OptionalString != nil
}

func (x *TestAllTypes) HasOptionalBytes() bool {
	if x == nil {
		return false
	}
	return x.OptionalBytes != nil
}

func (x *TestAllTypes) HasOptionalgroup() bool {
	if x == nil {
		return false
	}
	return x.Optionalgroup != nil
}

func (x *TestAllTypes) HasNotGroupLikeDelimited() bool {
	if x == nil {
		return false
	}
	return x.NotGroupLikeDelimited != nil
}

func (x *TestAllTypes) HasOptionalNestedMessage() bool {
	if x == nil {
		return false
	}
	return x.OptionalNestedMessage != nil
}

func (x *TestAllTypes) HasOptionalForeignMessage() bool {
	if x == nil {
		return false
	}
	return x.OptionalForeignMessage != nil
}

func (x *TestAllTypes) HasOptionalImportMessage() bool {
	if x == nil {
		return false
	}
	return x.OptionalImportMessage != nil
}

func (x *TestAllTypes) HasOptionalNestedEnum() bool {
	if x == nil {
		return false
	}
	return x.OptionalNestedEnum != nil
}

func (x *TestAllTypes) HasOptionalForeignEnum() bool {
	if x == nil {
		return false
	}
	return x.OptionalForeignEnum != nil
}

func (x *TestAllTypes) HasOptionalImportEnum() bool {
	if x == nil {
		return false
	}
	return x.OptionalImportEnum != nil
}

func (x *TestAllTypes) HasOptionalLazyNestedMessage() bool {
	if x == nil {
		return false
	}
	return x.OptionalLazyNestedMessage != nil
}

func (x *TestAllTypes) HasDefaultInt32() bool {
	if x == nil {
		return false
	}
	return x.DefaultInt32 != nil
}

func (x *TestAllTypes) HasDefaultInt64() bool {
	if x == nil {
		return false
	}
	return x.DefaultInt64 != nil
}

func (x *TestAllTypes) HasDefaultUint32() bool {
	if x == nil {
		return false
	}
	return x.DefaultUint32 != nil
}

func (x *TestAllTypes) HasDefaultUint64() bool {
	if x == nil {
		return false
	}
	return x.DefaultUint64 != nil
}

func (x *TestAllTypes) HasDefaultSint32() bool {
	if x == nil {
		return false
	}
	return x.DefaultSint32 != nil
}

func (x *TestAllTypes) HasDefaultSint64() bool {
	if x == nil {
		return false
	}
	return x.DefaultSint64 != nil
}

func (x *TestAllTypes) HasDefaultFixed32() bool {
	if x == nil {
		return false
	}
	return x.DefaultFixed32 != nil
}

func (x *TestAllTypes) HasDefaultFixed64() bool {
	if x == nil {
		return false
	}
	return x.DefaultFixed64 != nil
}

func (x *TestAllTypes) HasDefaultSfixed32() bool {
	if x == nil {
		return false
	}
	return x.DefaultSfixed32 != nil
}

func (x *TestAllTypes) HasDefaultSfixed64() bool {
	if x == nil {
		return false
	}
	return x.DefaultSfixed64 != nil
}

func (x *TestAllTypes) HasDefaultFloat() bool {
	if x == nil {
		return false
	}
	return x.DefaultFloat != nil
}

func (x *TestAllTypes) HasDefaultDouble() bool {
	if x == nil {
		return false
	}
	return x.DefaultDouble != nil
}

func (x *TestAllTypes) HasDefaultBool() bool {
	if x == nil {
		return false
	}
	return x.DefaultBool != nil
}

func (x *TestAllTypes) HasDefaultString() bool {
	if x == nil {
		return false
	}
	return x.DefaultString != nil
}

func (x *TestAllTypes) HasDefaultBytes() bool {
	if x == nil {
		return false
	}
	return x.DefaultBytes != nil
}

func (x *TestAllTypes) HasDefaultNestedEnum() bool {
	if x == nil {
		return false
	}
	return x.DefaultNestedEnum != nil
}

func (x *TestAllTypes) HasDefaultForeignEnum() bool {
	if x == nil {
		return false
	}
	return x.DefaultForeignEnum != nil
}

func (x *TestAllTypes) HasOneofField() bool {
	if x == nil {
		return false
	}
	return x.OneofField != nil
}

func (x *TestAllTypes) HasOneofUint32() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofUint32)
	return ok
}

func (x *TestAllTypes) HasOneofNestedMessage() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofNestedMessage)
	return ok
}

func (x *TestAllTypes) HasOneofString() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofString)
	return ok
}

func (x *TestAllTypes) HasOneofBytes() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofBytes)
	return ok
}

func (x *TestAllTypes) HasOneofBool() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofBool)
	return ok
}

func (x *TestAllTypes) HasOneofUint64() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofUint64)
	return ok
}

func (x *TestAllTypes) HasOneofFloat() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofFloat)
	return ok
}

func (x *TestAllTypes) HasOneofDouble() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofDouble)
	return ok
}

func (x *TestAllTypes) HasOneofEnum() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_OneofEnum)
	return ok
}

func (x *TestAllTypes) HasOneofgroup() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestAllTypes_Oneofgroup)
	return ok
}

func (x *TestAllTypes) HasOneofOptional() bool {
	if x == nil {
		return false
	}
	return x.OneofOptional != nil
}

func (x *TestAllTypes) HasOneofOptionalUint32() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofOptional.(*TestAllTypes_OneofOptionalUint32)
	return ok
}

func (x *TestAllTypes) ClearOptionalInt32() {
	x.OptionalInt32 = nil
}

func (x *TestAllTypes) ClearOptionalInt64() {
	x.OptionalInt64 = nil
}

func (x *TestAllTypes) ClearOptionalUint32() {
	x.OptionalUint32 = nil
}

func (x *TestAllTypes) ClearOptionalUint64() {
	x.OptionalUint64 = nil
}

func (x *TestAllTypes) ClearOptionalSint32() {
	x.OptionalSint32 = nil
}

func (x *TestAllTypes) ClearOptionalSint64() {
	x.OptionalSint64 = nil
}

func (x *TestAllTypes) ClearOptionalFixed32() {
	x.OptionalFixed32 = nil
}

func (x *TestAllTypes) ClearOptionalFixed64() {
	x.OptionalFixed64 = nil
}

func (x *TestAllTypes) ClearOptionalSfixed32() {
	x.OptionalSfixed32 = nil
}

func (x *TestAllTypes) ClearOptionalSfixed64() {
	x.OptionalSfixed64 = nil
}

func (x *TestAllTypes) ClearOptionalFloat() {
	x.OptionalFloat = nil
}

func (x *TestAllTypes) ClearOptionalDouble() {
	x.OptionalDouble = nil
}

func (x *TestAllTypes) ClearOptionalBool() {
	x.OptionalBool = nil
}

func (x *TestAllTypes) ClearOptionalString() {
	x.OptionalString = nil
}

func (x *TestAllTypes) ClearOptionalBytes() {
	x.OptionalBytes = nil
}

func (x *TestAllTypes) ClearOptionalgroup() {
	x.Optionalgroup = nil
}

func (x *TestAllTypes) ClearNotGroupLikeDelimited() {
	x.NotGroupLikeDelimited = nil
}

func (x *TestAllTypes) ClearOptionalNestedMessage() {
	x.OptionalNestedMessage = nil
}

func (x *TestAllTypes) ClearOptionalForeignMessage() {
	x.OptionalForeignMessage = nil
}

func (x *TestAllTypes) ClearOptionalImportMessage() {
	x.OptionalImportMessage = nil
}

func (x *TestAllTypes) ClearOptionalNestedEnum() {
	x.OptionalNestedEnum = nil
}

func (x *TestAllTypes) ClearOptionalForeignEnum() {
	x.OptionalForeignEnum = nil
}

func (x *TestAllTypes) ClearOptionalImportEnum() {
	x.OptionalImportEnum = nil
}

func (x *TestAllTypes) ClearOptionalLazyNestedMessage() {
	x.OptionalLazyNestedMessage = nil
}

func (x *TestAllTypes) ClearDefaultInt32() {
	x.DefaultInt32 = nil
}

func (x *TestAllTypes) ClearDefaultInt64() {
	x.DefaultInt64 = nil
}

func (x *TestAllTypes) ClearDefaultUint32() {
	x.DefaultUint32 = nil
}

func (x *TestAllTypes) ClearDefaultUint64() {
	x.DefaultUint64 = nil
}

func (x *TestAllTypes) ClearDefaultSint32() {
	x.DefaultSint32 = nil
}

func (x *TestAllTypes) ClearDefaultSint64() {
	x.DefaultSint64 = nil
}

func (x *TestAllTypes) ClearDefaultFixed32() {
	x.DefaultFixed32 = nil
}

func (x *TestAllTypes) ClearDefaultFixed64() {
	x.DefaultFixed64 = nil
}

func (x *TestAllTypes) ClearDefaultSfixed32() {
	x.DefaultSfixed32 = nil
}

func (x *TestAllTypes) ClearDefaultSfixed64() {
	x.DefaultSfixed64 = nil
}

func (x *TestAllTypes) ClearDefaultFloat() {
	x.DefaultFloat = nil
}

func (x *TestAllTypes) ClearDefaultDouble() {
	x.DefaultDouble = nil
}

func (x *TestAllTypes) ClearDefaultBool() {
	x.DefaultBool = nil
}

func (x *TestAllTypes) ClearDefaultString() {
	x.DefaultString = nil
}

func (x *TestAllTypes) ClearDefaultBytes() {
	x.DefaultBytes = nil
}

func (x *TestAllTypes) ClearDefaultNestedEnum() {
	x.DefaultNestedEnum = nil
}

func (x *TestAllTypes) ClearDefaultForeignEnum() {
	x.DefaultForeignEnum = nil
}

func (x *TestAllTypes) ClearOneofField() {
	x.OneofField = nil
}

func (x *TestAllTypes) ClearOneofUint32() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofUint32); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofNestedMessage() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofNestedMessage); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofString() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofString); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofBytes() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofBytes); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofBool() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofBool); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofUint64() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofUint64); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofFloat() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofFloat); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofDouble() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofDouble); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofEnum() {
	if _, ok := x.OneofField.(*TestAllTypes_OneofEnum); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofgroup() {
	if _, ok := x.OneofField.(*TestAllTypes_Oneofgroup); ok {
		x.OneofField = nil
	}
}

func (x *TestAllTypes) ClearOneofOptional() {
	x.OneofOptional = nil
}

func (x *TestAllTypes) ClearOneofOptionalUint32() {
	if _, ok := x.OneofOptional.(*TestAllTypes_OneofOptionalUint32); ok {
		x.OneofOptional = nil
	}
}

const TestAllTypes_OneofField_not_set_case case_TestAllTypes_OneofField = 0
const TestAllTypes_OneofUint32_case case_TestAllTypes_OneofField = 111
const TestAllTypes_OneofNestedMessage_case case_TestAllTypes_OneofField = 112
const TestAllTypes_OneofString_case case_TestAllTypes_OneofField = 113
const TestAllTypes_OneofBytes_case case_TestAllTypes_OneofField = 114
const TestAllTypes_OneofBool_case case_TestAllTypes_OneofField = 115
const TestAllTypes_OneofUint64_case case_TestAllTypes_OneofField = 116
const TestAllTypes_OneofFloat_case case_TestAllTypes_OneofField = 117
const TestAllTypes_OneofDouble_case case_TestAllTypes_OneofField = 118
const TestAllTypes_OneofEnum_case case_TestAllTypes_OneofField = 119
const TestAllTypes_Oneofgroup_case case_TestAllTypes_OneofField = 121

func (x *TestAllTypes) WhichOneofField() case_TestAllTypes_OneofField {
	if x == nil {
		return TestAllTypes_OneofField_not_set_case
	}
	switch x.OneofField.(type) {
	case *TestAllTypes_OneofUint32:
		return TestAllTypes_OneofUint32_case
	case *TestAllTypes_OneofNestedMessage:
		return TestAllTypes_OneofNestedMessage_case
	case *TestAllTypes_OneofString:
		return TestAllTypes_OneofString_case
	case *TestAllTypes_OneofBytes:
		return TestAllTypes_OneofBytes_case
	case *TestAllTypes_OneofBool:
		return TestAllTypes_OneofBool_case
	case *TestAllTypes_OneofUint64:
		return TestAllTypes_OneofUint64_case
	case *TestAllTypes_OneofFloat:
		return TestAllTypes_OneofFloat_case
	case *TestAllTypes_OneofDouble:
		return TestAllTypes_OneofDouble_case
	case *TestAllTypes_OneofEnum:
		return TestAllTypes_OneofEnum_case
	case *TestAllTypes_Oneofgroup:
		return TestAllTypes_Oneofgroup_case
	default:
		return TestAllTypes_OneofField_not_set_case
	}
}

const TestAllTypes_OneofOptional_not_set_case case_TestAllTypes_OneofOptional = 0
const TestAllTypes_OneofOptionalUint32_case case_TestAllTypes_OneofOptional = 120

func (x *TestAllTypes) WhichOneofOptional() case_TestAllTypes_OneofOptional {
	if x == nil {
		return TestAllTypes_OneofOptional_not_set_case
	}
	switch x.OneofOptional.(type) {
	case *TestAllTypes_OneofOptionalUint32:
		return TestAllTypes_OneofOptionalUint32_case
	default:
		return TestAllTypes_OneofOptional_not_set_case
	}
}

type TestAllTypes_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	SingularInt32    int32
	SingularInt64    int64
	SingularUint32   uint32
	SingularUint64   uint64
	SingularSint32   int32
	SingularSint64   int64
	SingularFixed32  uint32
	SingularFixed64  uint64
	SingularSfixed32 int32
	SingularSfixed64 int64
	SingularFloat    float32
	SingularDouble   float64
	SingularBool     bool
	SingularString   string
	SingularBytes    []byte
	// message-typed fields elided, as they cannot specify implicit presence.
	SingularNestedEnum        TestAllTypes_NestedEnum
	SingularForeignEnum       ForeignEnum
	SingularImportEnum        ImportEnum
	OptionalInt32             *int32
	OptionalInt64             *int64
	OptionalUint32            *uint32
	OptionalUint64            *uint64
	OptionalSint32            *int32
	OptionalSint64            *int64
	OptionalFixed32           *uint32
	OptionalFixed64           *uint64
	OptionalSfixed32          *int32
	OptionalSfixed64          *int64
	OptionalFloat             *float32
	OptionalDouble            *float64
	OptionalBool              *bool
	OptionalString            *string
	OptionalBytes             []byte
	Optionalgroup             *TestAllTypes_OptionalGroup
	NotGroupLikeDelimited     *TestAllTypes_OptionalGroup
	OptionalNestedMessage     *TestAllTypes_NestedMessage
	OptionalForeignMessage    *ForeignMessage
	OptionalImportMessage     *ImportMessage
	OptionalNestedEnum        *TestAllTypes_NestedEnum
	OptionalForeignEnum       *ForeignEnum
	OptionalImportEnum        *ImportEnum
	OptionalLazyNestedMessage *TestAllTypes_NestedMessage
	RepeatedInt32             []int32
	RepeatedInt64             []int64
	RepeatedUint32            []uint32
	RepeatedUint64            []uint64
	RepeatedSint32            []int32
	RepeatedSint64            []int64
	RepeatedFixed32           []uint32
	RepeatedFixed64           []uint64
	RepeatedSfixed32          []int32
	RepeatedSfixed64          []int64
	RepeatedFloat             []float32
	RepeatedDouble            []float64
	RepeatedBool              []bool
	RepeatedString            []string
	RepeatedBytes             [][]byte
	Repeatedgroup             []*TestAllTypes_RepeatedGroup
	RepeatedNestedMessage     []*TestAllTypes_NestedMessage
	RepeatedForeignMessage    []*ForeignMessage
	RepeatedImportmessage     []*ImportMessage
	RepeatedNestedEnum        []TestAllTypes_NestedEnum
	RepeatedForeignEnum       []ForeignEnum
	RepeatedImportenum        []ImportEnum
	MapInt32Int32             map[int32]int32
	MapInt64Int64             map[int64]int64
	MapUint32Uint32           map[uint32]uint32
	MapUint64Uint64           map[uint64]uint64
	MapSint32Sint32           map[int32]int32
	MapSint64Sint64           map[int64]int64
	MapFixed32Fixed32         map[uint32]uint32
	MapFixed64Fixed64         map[uint64]uint64
	MapSfixed32Sfixed32       map[int32]int32
	MapSfixed64Sfixed64       map[int64]int64
	MapInt32Float             map[int32]float32
	MapInt32Double            map[int32]float64
	MapBoolBool               map[bool]bool
	MapStringString           map[string]string
	MapStringBytes            map[string][]byte
	MapStringNestedMessage    map[string]*TestAllTypes_NestedMessage
	MapStringNestedEnum       map[string]TestAllTypes_NestedEnum
	// Singular with defaults
	DefaultInt32       *int32
	DefaultInt64       *int64
	DefaultUint32      *uint32
	DefaultUint64      *uint64
	DefaultSint32      *int32
	DefaultSint64      *int64
	DefaultFixed32     *uint32
	DefaultFixed64     *uint64
	DefaultSfixed32    *int32
	DefaultSfixed64    *int64
	DefaultFloat       *float32
	DefaultDouble      *float64
	DefaultBool        *bool
	DefaultString      *string
	DefaultBytes       []byte
	DefaultNestedEnum  *TestAllTypes_NestedEnum
	DefaultForeignEnum *ForeignEnum
	// Fields of oneof OneofField:
	OneofUint32        *uint32
	OneofNestedMessage *TestAllTypes_NestedMessage
	OneofString        *string
	OneofBytes         []byte
	OneofBool          *bool
	OneofUint64        *uint64
	OneofFloat         *float32
	OneofDouble        *float64
	OneofEnum          *TestAllTypes_NestedEnum
	Oneofgroup         *TestAllTypes_OneofGroup
	// -- end of OneofField
	// A oneof with exactly one field.

	// Fields of oneof OneofOptional:
	OneofOptionalUint32 *uint32
	// -- end of OneofOptional
}

func (b0 TestAllTypes_builder) Build() *TestAllTypes {
	m0 := &TestAllTypes{}
	b, x := &b0, m0
	_, _ = b, x
	x.SingularInt32 = b.SingularInt32
	x.SingularInt64 = b.SingularInt64
	x.SingularUint32 = b.SingularUint32
	x.SingularUint64 = b.SingularUint64
	x.SingularSint32 = b.SingularSint32
	x.SingularSint64 = b.SingularSint64
	x.SingularFixed32 = b.SingularFixed32
	x.SingularFixed64 = b.SingularFixed64
	x.SingularSfixed32 = b.SingularSfixed32
	x.SingularSfixed64 = b.SingularSfixed64
	x.SingularFloat = b.SingularFloat
	x.SingularDouble = b.SingularDouble
	x.SingularBool = b.SingularBool
	x.SingularString = b.SingularString
	x.SingularBytes = b.SingularBytes
	x.SingularNestedEnum = b.SingularNestedEnum
	x.SingularForeignEnum = b.SingularForeignEnum
	x.SingularImportEnum = b.SingularImportEnum
	x.OptionalInt32 = b.OptionalInt32
	x.OptionalInt64 = b.OptionalInt64
	x.OptionalUint32 = b.OptionalUint32
	x.OptionalUint64 = b.OptionalUint64
	x.OptionalSint32 = b.OptionalSint32
	x.OptionalSint64 = b.OptionalSint64
	x.OptionalFixed32 = b.OptionalFixed32
	x.OptionalFixed64 = b.OptionalFixed64
	x.OptionalSfixed32 = b.OptionalSfixed32
	x.OptionalSfixed64 = b.OptionalSfixed64
	x.OptionalFloat = b.OptionalFloat
	x.OptionalDouble = b.OptionalDouble
	x.OptionalBool = b.OptionalBool
	x.OptionalString = b.OptionalString
	x.OptionalBytes = b.OptionalBytes
	x.Optionalgroup = b.Optionalgroup
	x.NotGroupLikeDelimited = b.NotGroupLikeDelimited
	x.OptionalNestedMessage = b.OptionalNestedMessage
	x.OptionalForeignMessage = b.OptionalForeignMessage
	x.OptionalImportMessage = b.OptionalImportMessage
	x.OptionalNestedEnum = b.OptionalNestedEnum
	x.OptionalForeignEnum = b.OptionalForeignEnum
	x.OptionalImportEnum = b.OptionalImportEnum
	x.OptionalLazyNestedMessage = b.OptionalLazyNestedMessage
	x.RepeatedInt32 = b.RepeatedInt32
	x.RepeatedInt64 = b.RepeatedInt64
	x.RepeatedUint32 = b.RepeatedUint32
	x.RepeatedUint64 = b.RepeatedUint64
	x.RepeatedSint32 = b.RepeatedSint32
	x.RepeatedSint64 = b.RepeatedSint64
	x.RepeatedFixed32 = b.RepeatedFixed32
	x.RepeatedFixed64 = b.RepeatedFixed64
	x.RepeatedSfixed32 = b.RepeatedSfixed32
	x.RepeatedSfixed64 = b.RepeatedSfixed64
	x.RepeatedFloat = b.RepeatedFloat
	x.RepeatedDouble = b.RepeatedDouble
	x.RepeatedBool = b.RepeatedBool
	x.RepeatedString = b.RepeatedString
	x.RepeatedBytes = b.RepeatedBytes
	x.Repeatedgroup = b.Repeatedgroup
	x.RepeatedNestedMessage = b.RepeatedNestedMessage
	x.RepeatedForeignMessage = b.RepeatedForeignMessage
	x.RepeatedImportmessage = b.RepeatedImportmessage
	x.RepeatedNestedEnum = b.RepeatedNestedEnum
	x.RepeatedForeignEnum = b.RepeatedForeignEnum
	x.RepeatedImportenum = b.RepeatedImportenum
	x.MapInt32Int32 = b.MapInt32Int32
	x.MapInt64Int64 = b.MapInt64Int64
	x.MapUint32Uint32 = b.MapUint32Uint32
	x.MapUint64Uint64 = b.MapUint64Uint64
	x.MapSint32Sint32 = b.MapSint32Sint32
	x.MapSint64Sint64 = b.MapSint64Sint64
	x.MapFixed32Fixed32 = b.MapFixed32Fixed32
	x.MapFixed64Fixed64 = b.MapFixed64Fixed64
	x.MapSfixed32Sfixed32 = b.MapSfixed32Sfixed32
	x.MapSfixed64Sfixed64 = b.MapSfixed64Sfixed64
	x.MapInt32Float = b.MapInt32Float
	x.MapInt32Double = b.MapInt32Double
	x.MapBoolBool = b.MapBoolBool
	x.MapStringString = b.MapStringString
	x.MapStringBytes = b.MapStringBytes
	x.MapStringNestedMessage = b.MapStringNestedMessage
	x.MapStringNestedEnum = b.MapStringNestedEnum
	x.DefaultInt32 = b.DefaultInt32
	x.DefaultInt64 = b.DefaultInt64
	x.DefaultUint32 = b.DefaultUint32
	x.DefaultUint64 = b.DefaultUint64
	x.DefaultSint32 = b.DefaultSint32
	x.DefaultSint64 = b.DefaultSint64
	x.DefaultFixed32 = b.DefaultFixed32
	x.DefaultFixed64 = b.DefaultFixed64
	x.DefaultSfixed32 = b.DefaultSfixed32
	x.DefaultSfixed64 = b.DefaultSfixed64
	x.DefaultFloat = b.DefaultFloat
	x.DefaultDouble = b.DefaultDouble
	x.DefaultBool = b.DefaultBool
	x.DefaultString = b.DefaultString
	x.DefaultBytes = b.DefaultBytes
	x.DefaultNestedEnum = b.DefaultNestedEnum
	x.DefaultForeignEnum = b.DefaultForeignEnum
	if b.OneofUint32 != nil {
		x.OneofField = &TestAllTypes_OneofUint32{*b.OneofUint32}
	}
	if b.OneofNestedMessage != nil {
		x.OneofField = &TestAllTypes_OneofNestedMessage{b.OneofNestedMessage}
	}
	if b.OneofString != nil {
		x.OneofField = &TestAllTypes_OneofString{*b.OneofString}
	}
	if b.OneofBytes != nil {
		x.OneofField = &TestAllTypes_OneofBytes{b.OneofBytes}
	}
	if b.OneofBool != nil {
		x.OneofField = &TestAllTypes_OneofBool{*b.OneofBool}
	}
	if b.OneofUint64 != nil {
		x.OneofField = &TestAllTypes_OneofUint64{*b.OneofUint64}
	}
	if b.OneofFloat != nil {
		x.OneofField = &TestAllTypes_OneofFloat{*b.OneofFloat}
	}
	if b.OneofDouble != nil {
		x.OneofField = &TestAllTypes_OneofDouble{*b.OneofDouble}
	}
	if b.OneofEnum != nil {
		x.OneofField = &TestAllTypes_OneofEnum{*b.OneofEnum}
	}
	if b.Oneofgroup != nil {
		x.OneofField = &TestAllTypes_Oneofgroup{b.Oneofgroup}
	}
	if b.OneofOptionalUint32 != nil {
		x.OneofOptional = &TestAllTypes_OneofOptionalUint32{*b.OneofOptionalUint32}
	}
	return m0
}

type case_TestAllTypes_OneofField protoreflect.FieldNumber

func (x case_TestAllTypes_OneofField) String() string {
	md := file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[0].Descriptor()
	if x == 0 {
		return "not set"
	}
	return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x))
}

type case_TestAllTypes_OneofOptional protoreflect.FieldNumber

func (x case_TestAllTypes_OneofOptional) String() string {
	md := file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[0].Descriptor()
	if x == 0 {
		return "not set"
	}
	return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x))
}

type isTestAllTypes_OneofField interface {
	isTestAllTypes_OneofField()
}

type TestAllTypes_OneofUint32 struct {
	OneofUint32 uint32 `protobuf:"varint,111,opt,name=oneof_uint32,json=oneofUint32,oneof"`
}

type TestAllTypes_OneofNestedMessage struct {
	OneofNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,112,opt,name=oneof_nested_message,json=oneofNestedMessage,oneof"`
}

type TestAllTypes_OneofString struct {
	OneofString string `protobuf:"bytes,113,opt,name=oneof_string,json=oneofString,oneof"`
}

type TestAllTypes_OneofBytes struct {
	OneofBytes []byte `protobuf:"bytes,114,opt,name=oneof_bytes,json=oneofBytes,oneof"`
}

type TestAllTypes_OneofBool struct {
	OneofBool bool `protobuf:"varint,115,opt,name=oneof_bool,json=oneofBool,oneof"`
}

type TestAllTypes_OneofUint64 struct {
	OneofUint64 uint64 `protobuf:"varint,116,opt,name=oneof_uint64,json=oneofUint64,oneof"`
}

type TestAllTypes_OneofFloat struct {
	OneofFloat float32 `protobuf:"fixed32,117,opt,name=oneof_float,json=oneofFloat,oneof"`
}

type TestAllTypes_OneofDouble struct {
	OneofDouble float64 `protobuf:"fixed64,118,opt,name=oneof_double,json=oneofDouble,oneof"`
}

type TestAllTypes_OneofEnum struct {
	OneofEnum TestAllTypes_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,enum=hybrid.goproto.proto.testeditions.TestAllTypes_NestedEnum,oneof"`
}

type TestAllTypes_Oneofgroup struct {
	Oneofgroup *TestAllTypes_OneofGroup `protobuf:"group,121,opt,name=OneofGroup,json=oneofgroup,oneof"`
}

func (*TestAllTypes_OneofUint32) isTestAllTypes_OneofField() {}

func (*TestAllTypes_OneofNestedMessage) isTestAllTypes_OneofField() {}

func (*TestAllTypes_OneofString) isTestAllTypes_OneofField() {}

func (*TestAllTypes_OneofBytes) isTestAllTypes_OneofField() {}

func (*TestAllTypes_OneofBool) isTestAllTypes_OneofField() {}

func (*TestAllTypes_OneofUint64) isTestAllTypes_OneofField() {}

func (*TestAllTypes_OneofFloat) isTestAllTypes_OneofField() {}

func (*TestAllTypes_OneofDouble) isTestAllTypes_OneofField() {}

func (*TestAllTypes_OneofEnum) isTestAllTypes_OneofField() {}

func (*TestAllTypes_Oneofgroup) isTestAllTypes_OneofField() {}

type isTestAllTypes_OneofOptional interface {
	isTestAllTypes_OneofOptional()
}

type TestAllTypes_OneofOptionalUint32 struct {
	OneofOptionalUint32 uint32 `protobuf:"varint,120,opt,name=oneof_optional_uint32,json=oneofOptionalUint32,oneof"`
}

func (*TestAllTypes_OneofOptionalUint32) isTestAllTypes_OneofOptional() {}

type TestManyMessageFieldsMessage struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	F1            *TestAllTypes          `protobuf:"bytes,1,opt,name=f1" json:"f1,omitempty"`
	F2            *TestAllTypes          `protobuf:"bytes,2,opt,name=f2" json:"f2,omitempty"`
	F3            *TestAllTypes          `protobuf:"bytes,3,opt,name=f3" json:"f3,omitempty"`
	F4            *TestAllTypes          `protobuf:"bytes,4,opt,name=f4" json:"f4,omitempty"`
	F5            *TestAllTypes          `protobuf:"bytes,5,opt,name=f5" json:"f5,omitempty"`
	F6            *TestAllTypes          `protobuf:"bytes,6,opt,name=f6" json:"f6,omitempty"`
	F7            *TestAllTypes          `protobuf:"bytes,7,opt,name=f7" json:"f7,omitempty"`
	F8            *TestAllTypes          `protobuf:"bytes,8,opt,name=f8" json:"f8,omitempty"`
	F9            *TestAllTypes          `protobuf:"bytes,9,opt,name=f9" json:"f9,omitempty"`
	F10           *TestAllTypes          `protobuf:"bytes,10,opt,name=f10" json:"f10,omitempty"`
	F11           *TestAllTypes          `protobuf:"bytes,11,opt,name=f11" json:"f11,omitempty"`
	F12           *TestAllTypes          `protobuf:"bytes,12,opt,name=f12" json:"f12,omitempty"`
	F13           *TestAllTypes          `protobuf:"bytes,13,opt,name=f13" json:"f13,omitempty"`
	F14           *TestAllTypes          `protobuf:"bytes,14,opt,name=f14" json:"f14,omitempty"`
	F15           *TestAllTypes          `protobuf:"bytes,15,opt,name=f15" json:"f15,omitempty"`
	F16           *TestAllTypes          `protobuf:"bytes,16,opt,name=f16" json:"f16,omitempty"`
	F17           *TestAllTypes          `protobuf:"bytes,17,opt,name=f17" json:"f17,omitempty"`
	F18           *TestAllTypes          `protobuf:"bytes,18,opt,name=f18" json:"f18,omitempty"`
	F19           *TestAllTypes          `protobuf:"bytes,19,opt,name=f19" json:"f19,omitempty"`
	F20           *TestAllTypes          `protobuf:"bytes,20,opt,name=f20" json:"f20,omitempty"`
	F21           *TestAllTypes          `protobuf:"bytes,21,opt,name=f21" json:"f21,omitempty"`
	F22           *TestAllTypes          `protobuf:"bytes,22,opt,name=f22" json:"f22,omitempty"`
	F23           *TestAllTypes          `protobuf:"bytes,23,opt,name=f23" json:"f23,omitempty"`
	F24           *TestAllTypes          `protobuf:"bytes,24,opt,name=f24" json:"f24,omitempty"`
	F25           *TestAllTypes          `protobuf:"bytes,25,opt,name=f25" json:"f25,omitempty"`
	F26           *TestAllTypes          `protobuf:"bytes,26,opt,name=f26" json:"f26,omitempty"`
	F27           *TestAllTypes          `protobuf:"bytes,27,opt,name=f27" json:"f27,omitempty"`
	F28           *TestAllTypes          `protobuf:"bytes,28,opt,name=f28" json:"f28,omitempty"`
	F29           *TestAllTypes          `protobuf:"bytes,29,opt,name=f29" json:"f29,omitempty"`
	F30           *TestAllTypes          `protobuf:"bytes,30,opt,name=f30" json:"f30,omitempty"`
	F31           *TestAllTypes          `protobuf:"bytes,31,opt,name=f31" json:"f31,omitempty"`
	F32           *TestAllTypes          `protobuf:"bytes,32,opt,name=f32" json:"f32,omitempty"`
	F33           *TestAllTypes          `protobuf:"bytes,33,opt,name=f33" json:"f33,omitempty"`
	F34           *TestAllTypes          `protobuf:"bytes,34,opt,name=f34" json:"f34,omitempty"`
	F35           *TestAllTypes          `protobuf:"bytes,35,opt,name=f35" json:"f35,omitempty"`
	F36           *TestAllTypes          `protobuf:"bytes,36,opt,name=f36" json:"f36,omitempty"`
	F37           *TestAllTypes          `protobuf:"bytes,37,opt,name=f37" json:"f37,omitempty"`
	F38           *TestAllTypes          `protobuf:"bytes,38,opt,name=f38" json:"f38,omitempty"`
	F39           *TestAllTypes          `protobuf:"bytes,39,opt,name=f39" json:"f39,omitempty"`
	F40           *TestAllTypes          `protobuf:"bytes,40,opt,name=f40" json:"f40,omitempty"`
	F41           *TestAllTypes          `protobuf:"bytes,41,opt,name=f41" json:"f41,omitempty"`
	F42           *TestAllTypes          `protobuf:"bytes,42,opt,name=f42" json:"f42,omitempty"`
	F43           *TestAllTypes          `protobuf:"bytes,43,opt,name=f43" json:"f43,omitempty"`
	F44           *TestAllTypes          `protobuf:"bytes,44,opt,name=f44" json:"f44,omitempty"`
	F45           *TestAllTypes          `protobuf:"bytes,45,opt,name=f45" json:"f45,omitempty"`
	F46           *TestAllTypes          `protobuf:"bytes,46,opt,name=f46" json:"f46,omitempty"`
	F47           *TestAllTypes          `protobuf:"bytes,47,opt,name=f47" json:"f47,omitempty"`
	F48           *TestAllTypes          `protobuf:"bytes,48,opt,name=f48" json:"f48,omitempty"`
	F49           *TestAllTypes          `protobuf:"bytes,49,opt,name=f49" json:"f49,omitempty"`
	F50           *TestAllTypes          `protobuf:"bytes,50,opt,name=f50" json:"f50,omitempty"`
	F51           *TestAllTypes          `protobuf:"bytes,51,opt,name=f51" json:"f51,omitempty"`
	F52           *TestAllTypes          `protobuf:"bytes,52,opt,name=f52" json:"f52,omitempty"`
	F53           *TestAllTypes          `protobuf:"bytes,53,opt,name=f53" json:"f53,omitempty"`
	F54           *TestAllTypes          `protobuf:"bytes,54,opt,name=f54" json:"f54,omitempty"`
	F55           *TestAllTypes          `protobuf:"bytes,55,opt,name=f55" json:"f55,omitempty"`
	F56           *TestAllTypes          `protobuf:"bytes,56,opt,name=f56" json:"f56,omitempty"`
	F57           *TestAllTypes          `protobuf:"bytes,57,opt,name=f57" json:"f57,omitempty"`
	F58           *TestAllTypes          `protobuf:"bytes,58,opt,name=f58" json:"f58,omitempty"`
	F59           *TestAllTypes          `protobuf:"bytes,59,opt,name=f59" json:"f59,omitempty"`
	F60           *TestAllTypes          `protobuf:"bytes,60,opt,name=f60" json:"f60,omitempty"`
	F61           *TestAllTypes          `protobuf:"bytes,61,opt,name=f61" json:"f61,omitempty"`
	F62           *TestAllTypes          `protobuf:"bytes,62,opt,name=f62" json:"f62,omitempty"`
	F63           *TestAllTypes          `protobuf:"bytes,63,opt,name=f63" json:"f63,omitempty"`
	F64           *TestAllTypes          `protobuf:"bytes,64,opt,name=f64" json:"f64,omitempty"`
	F65           *TestAllTypes          `protobuf:"bytes,65,opt,name=f65" json:"f65,omitempty"`
	F66           *TestAllTypes          `protobuf:"bytes,66,opt,name=f66" json:"f66,omitempty"`
	F67           *TestAllTypes          `protobuf:"bytes,67,opt,name=f67" json:"f67,omitempty"`
	F68           *TestAllTypes          `protobuf:"bytes,68,opt,name=f68" json:"f68,omitempty"`
	F69           *TestAllTypes          `protobuf:"bytes,69,opt,name=f69" json:"f69,omitempty"`
	F70           *TestAllTypes          `protobuf:"bytes,70,opt,name=f70" json:"f70,omitempty"`
	F71           *TestAllTypes          `protobuf:"bytes,71,opt,name=f71" json:"f71,omitempty"`
	F72           *TestAllTypes          `protobuf:"bytes,72,opt,name=f72" json:"f72,omitempty"`
	F73           *TestAllTypes          `protobuf:"bytes,73,opt,name=f73" json:"f73,omitempty"`
	F74           *TestAllTypes          `protobuf:"bytes,74,opt,name=f74" json:"f74,omitempty"`
	F75           *TestAllTypes          `protobuf:"bytes,75,opt,name=f75" json:"f75,omitempty"`
	F76           *TestAllTypes          `protobuf:"bytes,76,opt,name=f76" json:"f76,omitempty"`
	F77           *TestAllTypes          `protobuf:"bytes,77,opt,name=f77" json:"f77,omitempty"`
	F78           *TestAllTypes          `protobuf:"bytes,78,opt,name=f78" json:"f78,omitempty"`
	F79           *TestAllTypes          `protobuf:"bytes,79,opt,name=f79" json:"f79,omitempty"`
	F80           *TestAllTypes          `protobuf:"bytes,80,opt,name=f80" json:"f80,omitempty"`
	F81           *TestAllTypes          `protobuf:"bytes,81,opt,name=f81" json:"f81,omitempty"`
	F82           *TestAllTypes          `protobuf:"bytes,82,opt,name=f82" json:"f82,omitempty"`
	F83           *TestAllTypes          `protobuf:"bytes,83,opt,name=f83" json:"f83,omitempty"`
	F84           *TestAllTypes          `protobuf:"bytes,84,opt,name=f84" json:"f84,omitempty"`
	F85           *TestAllTypes          `protobuf:"bytes,85,opt,name=f85" json:"f85,omitempty"`
	F86           *TestAllTypes          `protobuf:"bytes,86,opt,name=f86" json:"f86,omitempty"`
	F87           *TestAllTypes          `protobuf:"bytes,87,opt,name=f87" json:"f87,omitempty"`
	F88           *TestAllTypes          `protobuf:"bytes,88,opt,name=f88" json:"f88,omitempty"`
	F89           *TestAllTypes          `protobuf:"bytes,89,opt,name=f89" json:"f89,omitempty"`
	F90           *TestAllTypes          `protobuf:"bytes,90,opt,name=f90" json:"f90,omitempty"`
	F91           *TestAllTypes          `protobuf:"bytes,91,opt,name=f91" json:"f91,omitempty"`
	F92           *TestAllTypes          `protobuf:"bytes,92,opt,name=f92" json:"f92,omitempty"`
	F93           *TestAllTypes          `protobuf:"bytes,93,opt,name=f93" json:"f93,omitempty"`
	F94           *TestAllTypes          `protobuf:"bytes,94,opt,name=f94" json:"f94,omitempty"`
	F95           *TestAllTypes          `protobuf:"bytes,95,opt,name=f95" json:"f95,omitempty"`
	F96           *TestAllTypes          `protobuf:"bytes,96,opt,name=f96" json:"f96,omitempty"`
	F97           *TestAllTypes          `protobuf:"bytes,97,opt,name=f97" json:"f97,omitempty"`
	F98           *TestAllTypes          `protobuf:"bytes,98,opt,name=f98" json:"f98,omitempty"`
	F99           *TestAllTypes          `protobuf:"bytes,99,opt,name=f99" json:"f99,omitempty"`
	F100          *TestAllTypes          `protobuf:"bytes,100,opt,name=f100" json:"f100,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestManyMessageFieldsMessage) Reset() {
	*x = TestManyMessageFieldsMessage{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestManyMessageFieldsMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestManyMessageFieldsMessage) ProtoMessage() {}

func (x *TestManyMessageFieldsMessage) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestManyMessageFieldsMessage) GetF1() *TestAllTypes {
	if x != nil {
		return x.F1
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF2() *TestAllTypes {
	if x != nil {
		return x.F2
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF3() *TestAllTypes {
	if x != nil {
		return x.F3
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF4() *TestAllTypes {
	if x != nil {
		return x.F4
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF5() *TestAllTypes {
	if x != nil {
		return x.F5
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF6() *TestAllTypes {
	if x != nil {
		return x.F6
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF7() *TestAllTypes {
	if x != nil {
		return x.F7
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF8() *TestAllTypes {
	if x != nil {
		return x.F8
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF9() *TestAllTypes {
	if x != nil {
		return x.F9
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF10() *TestAllTypes {
	if x != nil {
		return x.F10
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF11() *TestAllTypes {
	if x != nil {
		return x.F11
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF12() *TestAllTypes {
	if x != nil {
		return x.F12
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF13() *TestAllTypes {
	if x != nil {
		return x.F13
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF14() *TestAllTypes {
	if x != nil {
		return x.F14
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF15() *TestAllTypes {
	if x != nil {
		return x.F15
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF16() *TestAllTypes {
	if x != nil {
		return x.F16
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF17() *TestAllTypes {
	if x != nil {
		return x.F17
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF18() *TestAllTypes {
	if x != nil {
		return x.F18
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF19() *TestAllTypes {
	if x != nil {
		return x.F19
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF20() *TestAllTypes {
	if x != nil {
		return x.F20
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF21() *TestAllTypes {
	if x != nil {
		return x.F21
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF22() *TestAllTypes {
	if x != nil {
		return x.F22
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF23() *TestAllTypes {
	if x != nil {
		return x.F23
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF24() *TestAllTypes {
	if x != nil {
		return x.F24
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF25() *TestAllTypes {
	if x != nil {
		return x.F25
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF26() *TestAllTypes {
	if x != nil {
		return x.F26
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF27() *TestAllTypes {
	if x != nil {
		return x.F27
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF28() *TestAllTypes {
	if x != nil {
		return x.F28
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF29() *TestAllTypes {
	if x != nil {
		return x.F29
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF30() *TestAllTypes {
	if x != nil {
		return x.F30
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF31() *TestAllTypes {
	if x != nil {
		return x.F31
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF32() *TestAllTypes {
	if x != nil {
		return x.F32
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF33() *TestAllTypes {
	if x != nil {
		return x.F33
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF34() *TestAllTypes {
	if x != nil {
		return x.F34
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF35() *TestAllTypes {
	if x != nil {
		return x.F35
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF36() *TestAllTypes {
	if x != nil {
		return x.F36
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF37() *TestAllTypes {
	if x != nil {
		return x.F37
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF38() *TestAllTypes {
	if x != nil {
		return x.F38
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF39() *TestAllTypes {
	if x != nil {
		return x.F39
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF40() *TestAllTypes {
	if x != nil {
		return x.F40
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF41() *TestAllTypes {
	if x != nil {
		return x.F41
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF42() *TestAllTypes {
	if x != nil {
		return x.F42
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF43() *TestAllTypes {
	if x != nil {
		return x.F43
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF44() *TestAllTypes {
	if x != nil {
		return x.F44
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF45() *TestAllTypes {
	if x != nil {
		return x.F45
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF46() *TestAllTypes {
	if x != nil {
		return x.F46
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF47() *TestAllTypes {
	if x != nil {
		return x.F47
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF48() *TestAllTypes {
	if x != nil {
		return x.F48
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF49() *TestAllTypes {
	if x != nil {
		return x.F49
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF50() *TestAllTypes {
	if x != nil {
		return x.F50
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF51() *TestAllTypes {
	if x != nil {
		return x.F51
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF52() *TestAllTypes {
	if x != nil {
		return x.F52
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF53() *TestAllTypes {
	if x != nil {
		return x.F53
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF54() *TestAllTypes {
	if x != nil {
		return x.F54
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF55() *TestAllTypes {
	if x != nil {
		return x.F55
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF56() *TestAllTypes {
	if x != nil {
		return x.F56
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF57() *TestAllTypes {
	if x != nil {
		return x.F57
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF58() *TestAllTypes {
	if x != nil {
		return x.F58
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF59() *TestAllTypes {
	if x != nil {
		return x.F59
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF60() *TestAllTypes {
	if x != nil {
		return x.F60
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF61() *TestAllTypes {
	if x != nil {
		return x.F61
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF62() *TestAllTypes {
	if x != nil {
		return x.F62
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF63() *TestAllTypes {
	if x != nil {
		return x.F63
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF64() *TestAllTypes {
	if x != nil {
		return x.F64
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF65() *TestAllTypes {
	if x != nil {
		return x.F65
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF66() *TestAllTypes {
	if x != nil {
		return x.F66
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF67() *TestAllTypes {
	if x != nil {
		return x.F67
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF68() *TestAllTypes {
	if x != nil {
		return x.F68
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF69() *TestAllTypes {
	if x != nil {
		return x.F69
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF70() *TestAllTypes {
	if x != nil {
		return x.F70
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF71() *TestAllTypes {
	if x != nil {
		return x.F71
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF72() *TestAllTypes {
	if x != nil {
		return x.F72
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF73() *TestAllTypes {
	if x != nil {
		return x.F73
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF74() *TestAllTypes {
	if x != nil {
		return x.F74
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF75() *TestAllTypes {
	if x != nil {
		return x.F75
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF76() *TestAllTypes {
	if x != nil {
		return x.F76
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF77() *TestAllTypes {
	if x != nil {
		return x.F77
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF78() *TestAllTypes {
	if x != nil {
		return x.F78
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF79() *TestAllTypes {
	if x != nil {
		return x.F79
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF80() *TestAllTypes {
	if x != nil {
		return x.F80
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF81() *TestAllTypes {
	if x != nil {
		return x.F81
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF82() *TestAllTypes {
	if x != nil {
		return x.F82
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF83() *TestAllTypes {
	if x != nil {
		return x.F83
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF84() *TestAllTypes {
	if x != nil {
		return x.F84
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF85() *TestAllTypes {
	if x != nil {
		return x.F85
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF86() *TestAllTypes {
	if x != nil {
		return x.F86
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF87() *TestAllTypes {
	if x != nil {
		return x.F87
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF88() *TestAllTypes {
	if x != nil {
		return x.F88
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF89() *TestAllTypes {
	if x != nil {
		return x.F89
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF90() *TestAllTypes {
	if x != nil {
		return x.F90
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF91() *TestAllTypes {
	if x != nil {
		return x.F91
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF92() *TestAllTypes {
	if x != nil {
		return x.F92
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF93() *TestAllTypes {
	if x != nil {
		return x.F93
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF94() *TestAllTypes {
	if x != nil {
		return x.F94
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF95() *TestAllTypes {
	if x != nil {
		return x.F95
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF96() *TestAllTypes {
	if x != nil {
		return x.F96
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF97() *TestAllTypes {
	if x != nil {
		return x.F97
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF98() *TestAllTypes {
	if x != nil {
		return x.F98
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF99() *TestAllTypes {
	if x != nil {
		return x.F99
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) GetF100() *TestAllTypes {
	if x != nil {
		return x.F100
	}
	return nil
}

func (x *TestManyMessageFieldsMessage) SetF1(v *TestAllTypes) {
	x.F1 = v
}

func (x *TestManyMessageFieldsMessage) SetF2(v *TestAllTypes) {
	x.F2 = v
}

func (x *TestManyMessageFieldsMessage) SetF3(v *TestAllTypes) {
	x.F3 = v
}

func (x *TestManyMessageFieldsMessage) SetF4(v *TestAllTypes) {
	x.F4 = v
}

func (x *TestManyMessageFieldsMessage) SetF5(v *TestAllTypes) {
	x.F5 = v
}

func (x *TestManyMessageFieldsMessage) SetF6(v *TestAllTypes) {
	x.F6 = v
}

func (x *TestManyMessageFieldsMessage) SetF7(v *TestAllTypes) {
	x.F7 = v
}

func (x *TestManyMessageFieldsMessage) SetF8(v *TestAllTypes) {
	x.F8 = v
}

func (x *TestManyMessageFieldsMessage) SetF9(v *TestAllTypes) {
	x.F9 = v
}

func (x *TestManyMessageFieldsMessage) SetF10(v *TestAllTypes) {
	x.F10 = v
}

func (x *TestManyMessageFieldsMessage) SetF11(v *TestAllTypes) {
	x.F11 = v
}

func (x *TestManyMessageFieldsMessage) SetF12(v *TestAllTypes) {
	x.F12 = v
}

func (x *TestManyMessageFieldsMessage) SetF13(v *TestAllTypes) {
	x.F13 = v
}

func (x *TestManyMessageFieldsMessage) SetF14(v *TestAllTypes) {
	x.F14 = v
}

func (x *TestManyMessageFieldsMessage) SetF15(v *TestAllTypes) {
	x.F15 = v
}

func (x *TestManyMessageFieldsMessage) SetF16(v *TestAllTypes) {
	x.F16 = v
}

func (x *TestManyMessageFieldsMessage) SetF17(v *TestAllTypes) {
	x.F17 = v
}

func (x *TestManyMessageFieldsMessage) SetF18(v *TestAllTypes) {
	x.F18 = v
}

func (x *TestManyMessageFieldsMessage) SetF19(v *TestAllTypes) {
	x.F19 = v
}

func (x *TestManyMessageFieldsMessage) SetF20(v *TestAllTypes) {
	x.F20 = v
}

func (x *TestManyMessageFieldsMessage) SetF21(v *TestAllTypes) {
	x.F21 = v
}

func (x *TestManyMessageFieldsMessage) SetF22(v *TestAllTypes) {
	x.F22 = v
}

func (x *TestManyMessageFieldsMessage) SetF23(v *TestAllTypes) {
	x.F23 = v
}

func (x *TestManyMessageFieldsMessage) SetF24(v *TestAllTypes) {
	x.F24 = v
}

func (x *TestManyMessageFieldsMessage) SetF25(v *TestAllTypes) {
	x.F25 = v
}

func (x *TestManyMessageFieldsMessage) SetF26(v *TestAllTypes) {
	x.F26 = v
}

func (x *TestManyMessageFieldsMessage) SetF27(v *TestAllTypes) {
	x.F27 = v
}

func (x *TestManyMessageFieldsMessage) SetF28(v *TestAllTypes) {
	x.F28 = v
}

func (x *TestManyMessageFieldsMessage) SetF29(v *TestAllTypes) {
	x.F29 = v
}

func (x *TestManyMessageFieldsMessage) SetF30(v *TestAllTypes) {
	x.F30 = v
}

func (x *TestManyMessageFieldsMessage) SetF31(v *TestAllTypes) {
	x.F31 = v
}

func (x *TestManyMessageFieldsMessage) SetF32(v *TestAllTypes) {
	x.F32 = v
}

func (x *TestManyMessageFieldsMessage) SetF33(v *TestAllTypes) {
	x.F33 = v
}

func (x *TestManyMessageFieldsMessage) SetF34(v *TestAllTypes) {
	x.F34 = v
}

func (x *TestManyMessageFieldsMessage) SetF35(v *TestAllTypes) {
	x.F35 = v
}

func (x *TestManyMessageFieldsMessage) SetF36(v *TestAllTypes) {
	x.F36 = v
}

func (x *TestManyMessageFieldsMessage) SetF37(v *TestAllTypes) {
	x.F37 = v
}

func (x *TestManyMessageFieldsMessage) SetF38(v *TestAllTypes) {
	x.F38 = v
}

func (x *TestManyMessageFieldsMessage) SetF39(v *TestAllTypes) {
	x.F39 = v
}

func (x *TestManyMessageFieldsMessage) SetF40(v *TestAllTypes) {
	x.F40 = v
}

func (x *TestManyMessageFieldsMessage) SetF41(v *TestAllTypes) {
	x.F41 = v
}

func (x *TestManyMessageFieldsMessage) SetF42(v *TestAllTypes) {
	x.F42 = v
}

func (x *TestManyMessageFieldsMessage) SetF43(v *TestAllTypes) {
	x.F43 = v
}

func (x *TestManyMessageFieldsMessage) SetF44(v *TestAllTypes) {
	x.F44 = v
}

func (x *TestManyMessageFieldsMessage) SetF45(v *TestAllTypes) {
	x.F45 = v
}

func (x *TestManyMessageFieldsMessage) SetF46(v *TestAllTypes) {
	x.F46 = v
}

func (x *TestManyMessageFieldsMessage) SetF47(v *TestAllTypes) {
	x.F47 = v
}

func (x *TestManyMessageFieldsMessage) SetF48(v *TestAllTypes) {
	x.F48 = v
}

func (x *TestManyMessageFieldsMessage) SetF49(v *TestAllTypes) {
	x.F49 = v
}

func (x *TestManyMessageFieldsMessage) SetF50(v *TestAllTypes) {
	x.F50 = v
}

func (x *TestManyMessageFieldsMessage) SetF51(v *TestAllTypes) {
	x.F51 = v
}

func (x *TestManyMessageFieldsMessage) SetF52(v *TestAllTypes) {
	x.F52 = v
}

func (x *TestManyMessageFieldsMessage) SetF53(v *TestAllTypes) {
	x.F53 = v
}

func (x *TestManyMessageFieldsMessage) SetF54(v *TestAllTypes) {
	x.F54 = v
}

func (x *TestManyMessageFieldsMessage) SetF55(v *TestAllTypes) {
	x.F55 = v
}

func (x *TestManyMessageFieldsMessage) SetF56(v *TestAllTypes) {
	x.F56 = v
}

func (x *TestManyMessageFieldsMessage) SetF57(v *TestAllTypes) {
	x.F57 = v
}

func (x *TestManyMessageFieldsMessage) SetF58(v *TestAllTypes) {
	x.F58 = v
}

func (x *TestManyMessageFieldsMessage) SetF59(v *TestAllTypes) {
	x.F59 = v
}

func (x *TestManyMessageFieldsMessage) SetF60(v *TestAllTypes) {
	x.F60 = v
}

func (x *TestManyMessageFieldsMessage) SetF61(v *TestAllTypes) {
	x.F61 = v
}

func (x *TestManyMessageFieldsMessage) SetF62(v *TestAllTypes) {
	x.F62 = v
}

func (x *TestManyMessageFieldsMessage) SetF63(v *TestAllTypes) {
	x.F63 = v
}

func (x *TestManyMessageFieldsMessage) SetF64(v *TestAllTypes) {
	x.F64 = v
}

func (x *TestManyMessageFieldsMessage) SetF65(v *TestAllTypes) {
	x.F65 = v
}

func (x *TestManyMessageFieldsMessage) SetF66(v *TestAllTypes) {
	x.F66 = v
}

func (x *TestManyMessageFieldsMessage) SetF67(v *TestAllTypes) {
	x.F67 = v
}

func (x *TestManyMessageFieldsMessage) SetF68(v *TestAllTypes) {
	x.F68 = v
}

func (x *TestManyMessageFieldsMessage) SetF69(v *TestAllTypes) {
	x.F69 = v
}

func (x *TestManyMessageFieldsMessage) SetF70(v *TestAllTypes) {
	x.F70 = v
}

func (x *TestManyMessageFieldsMessage) SetF71(v *TestAllTypes) {
	x.F71 = v
}

func (x *TestManyMessageFieldsMessage) SetF72(v *TestAllTypes) {
	x.F72 = v
}

func (x *TestManyMessageFieldsMessage) SetF73(v *TestAllTypes) {
	x.F73 = v
}

func (x *TestManyMessageFieldsMessage) SetF74(v *TestAllTypes) {
	x.F74 = v
}

func (x *TestManyMessageFieldsMessage) SetF75(v *TestAllTypes) {
	x.F75 = v
}

func (x *TestManyMessageFieldsMessage) SetF76(v *TestAllTypes) {
	x.F76 = v
}

func (x *TestManyMessageFieldsMessage) SetF77(v *TestAllTypes) {
	x.F77 = v
}

func (x *TestManyMessageFieldsMessage) SetF78(v *TestAllTypes) {
	x.F78 = v
}

func (x *TestManyMessageFieldsMessage) SetF79(v *TestAllTypes) {
	x.F79 = v
}

func (x *TestManyMessageFieldsMessage) SetF80(v *TestAllTypes) {
	x.F80 = v
}

func (x *TestManyMessageFieldsMessage) SetF81(v *TestAllTypes) {
	x.F81 = v
}

func (x *TestManyMessageFieldsMessage) SetF82(v *TestAllTypes) {
	x.F82 = v
}

func (x *TestManyMessageFieldsMessage) SetF83(v *TestAllTypes) {
	x.F83 = v
}

func (x *TestManyMessageFieldsMessage) SetF84(v *TestAllTypes) {
	x.F84 = v
}

func (x *TestManyMessageFieldsMessage) SetF85(v *TestAllTypes) {
	x.F85 = v
}

func (x *TestManyMessageFieldsMessage) SetF86(v *TestAllTypes) {
	x.F86 = v
}

func (x *TestManyMessageFieldsMessage) SetF87(v *TestAllTypes) {
	x.F87 = v
}

func (x *TestManyMessageFieldsMessage) SetF88(v *TestAllTypes) {
	x.F88 = v
}

func (x *TestManyMessageFieldsMessage) SetF89(v *TestAllTypes) {
	x.F89 = v
}

func (x *TestManyMessageFieldsMessage) SetF90(v *TestAllTypes) {
	x.F90 = v
}

func (x *TestManyMessageFieldsMessage) SetF91(v *TestAllTypes) {
	x.F91 = v
}

func (x *TestManyMessageFieldsMessage) SetF92(v *TestAllTypes) {
	x.F92 = v
}

func (x *TestManyMessageFieldsMessage) SetF93(v *TestAllTypes) {
	x.F93 = v
}

func (x *TestManyMessageFieldsMessage) SetF94(v *TestAllTypes) {
	x.F94 = v
}

func (x *TestManyMessageFieldsMessage) SetF95(v *TestAllTypes) {
	x.F95 = v
}

func (x *TestManyMessageFieldsMessage) SetF96(v *TestAllTypes) {
	x.F96 = v
}

func (x *TestManyMessageFieldsMessage) SetF97(v *TestAllTypes) {
	x.F97 = v
}

func (x *TestManyMessageFieldsMessage) SetF98(v *TestAllTypes) {
	x.F98 = v
}

func (x *TestManyMessageFieldsMessage) SetF99(v *TestAllTypes) {
	x.F99 = v
}

func (x *TestManyMessageFieldsMessage) SetF100(v *TestAllTypes) {
	x.F100 = v
}

func (x *TestManyMessageFieldsMessage) HasF1() bool {
	if x == nil {
		return false
	}
	return x.F1 != nil
}

func (x *TestManyMessageFieldsMessage) HasF2() bool {
	if x == nil {
		return false
	}
	return x.F2 != nil
}

func (x *TestManyMessageFieldsMessage) HasF3() bool {
	if x == nil {
		return false
	}
	return x.F3 != nil
}

func (x *TestManyMessageFieldsMessage) HasF4() bool {
	if x == nil {
		return false
	}
	return x.F4 != nil
}

func (x *TestManyMessageFieldsMessage) HasF5() bool {
	if x == nil {
		return false
	}
	return x.F5 != nil
}

func (x *TestManyMessageFieldsMessage) HasF6() bool {
	if x == nil {
		return false
	}
	return x.F6 != nil
}

func (x *TestManyMessageFieldsMessage) HasF7() bool {
	if x == nil {
		return false
	}
	return x.F7 != nil
}

func (x *TestManyMessageFieldsMessage) HasF8() bool {
	if x == nil {
		return false
	}
	return x.F8 != nil
}

func (x *TestManyMessageFieldsMessage) HasF9() bool {
	if x == nil {
		return false
	}
	return x.F9 != nil
}

func (x *TestManyMessageFieldsMessage) HasF10() bool {
	if x == nil {
		return false
	}
	return x.F10 != nil
}

func (x *TestManyMessageFieldsMessage) HasF11() bool {
	if x == nil {
		return false
	}
	return x.F11 != nil
}

func (x *TestManyMessageFieldsMessage) HasF12() bool {
	if x == nil {
		return false
	}
	return x.F12 != nil
}

func (x *TestManyMessageFieldsMessage) HasF13() bool {
	if x == nil {
		return false
	}
	return x.F13 != nil
}

func (x *TestManyMessageFieldsMessage) HasF14() bool {
	if x == nil {
		return false
	}
	return x.F14 != nil
}

func (x *TestManyMessageFieldsMessage) HasF15() bool {
	if x == nil {
		return false
	}
	return x.F15 != nil
}

func (x *TestManyMessageFieldsMessage) HasF16() bool {
	if x == nil {
		return false
	}
	return x.F16 != nil
}

func (x *TestManyMessageFieldsMessage) HasF17() bool {
	if x == nil {
		return false
	}
	return x.F17 != nil
}

func (x *TestManyMessageFieldsMessage) HasF18() bool {
	if x == nil {
		return false
	}
	return x.F18 != nil
}

func (x *TestManyMessageFieldsMessage) HasF19() bool {
	if x == nil {
		return false
	}
	return x.F19 != nil
}

func (x *TestManyMessageFieldsMessage) HasF20() bool {
	if x == nil {
		return false
	}
	return x.F20 != nil
}

func (x *TestManyMessageFieldsMessage) HasF21() bool {
	if x == nil {
		return false
	}
	return x.F21 != nil
}

func (x *TestManyMessageFieldsMessage) HasF22() bool {
	if x == nil {
		return false
	}
	return x.F22 != nil
}

func (x *TestManyMessageFieldsMessage) HasF23() bool {
	if x == nil {
		return false
	}
	return x.F23 != nil
}

func (x *TestManyMessageFieldsMessage) HasF24() bool {
	if x == nil {
		return false
	}
	return x.F24 != nil
}

func (x *TestManyMessageFieldsMessage) HasF25() bool {
	if x == nil {
		return false
	}
	return x.F25 != nil
}

func (x *TestManyMessageFieldsMessage) HasF26() bool {
	if x == nil {
		return false
	}
	return x.F26 != nil
}

func (x *TestManyMessageFieldsMessage) HasF27() bool {
	if x == nil {
		return false
	}
	return x.F27 != nil
}

func (x *TestManyMessageFieldsMessage) HasF28() bool {
	if x == nil {
		return false
	}
	return x.F28 != nil
}

func (x *TestManyMessageFieldsMessage) HasF29() bool {
	if x == nil {
		return false
	}
	return x.F29 != nil
}

func (x *TestManyMessageFieldsMessage) HasF30() bool {
	if x == nil {
		return false
	}
	return x.F30 != nil
}

func (x *TestManyMessageFieldsMessage) HasF31() bool {
	if x == nil {
		return false
	}
	return x.F31 != nil
}

func (x *TestManyMessageFieldsMessage) HasF32() bool {
	if x == nil {
		return false
	}
	return x.F32 != nil
}

func (x *TestManyMessageFieldsMessage) HasF33() bool {
	if x == nil {
		return false
	}
	return x.F33 != nil
}

func (x *TestManyMessageFieldsMessage) HasF34() bool {
	if x == nil {
		return false
	}
	return x.F34 != nil
}

func (x *TestManyMessageFieldsMessage) HasF35() bool {
	if x == nil {
		return false
	}
	return x.F35 != nil
}

func (x *TestManyMessageFieldsMessage) HasF36() bool {
	if x == nil {
		return false
	}
	return x.F36 != nil
}

func (x *TestManyMessageFieldsMessage) HasF37() bool {
	if x == nil {
		return false
	}
	return x.F37 != nil
}

func (x *TestManyMessageFieldsMessage) HasF38() bool {
	if x == nil {
		return false
	}
	return x.F38 != nil
}

func (x *TestManyMessageFieldsMessage) HasF39() bool {
	if x == nil {
		return false
	}
	return x.F39 != nil
}

func (x *TestManyMessageFieldsMessage) HasF40() bool {
	if x == nil {
		return false
	}
	return x.F40 != nil
}

func (x *TestManyMessageFieldsMessage) HasF41() bool {
	if x == nil {
		return false
	}
	return x.F41 != nil
}

func (x *TestManyMessageFieldsMessage) HasF42() bool {
	if x == nil {
		return false
	}
	return x.F42 != nil
}

func (x *TestManyMessageFieldsMessage) HasF43() bool {
	if x == nil {
		return false
	}
	return x.F43 != nil
}

func (x *TestManyMessageFieldsMessage) HasF44() bool {
	if x == nil {
		return false
	}
	return x.F44 != nil
}

func (x *TestManyMessageFieldsMessage) HasF45() bool {
	if x == nil {
		return false
	}
	return x.F45 != nil
}

func (x *TestManyMessageFieldsMessage) HasF46() bool {
	if x == nil {
		return false
	}
	return x.F46 != nil
}

func (x *TestManyMessageFieldsMessage) HasF47() bool {
	if x == nil {
		return false
	}
	return x.F47 != nil
}

func (x *TestManyMessageFieldsMessage) HasF48() bool {
	if x == nil {
		return false
	}
	return x.F48 != nil
}

func (x *TestManyMessageFieldsMessage) HasF49() bool {
	if x == nil {
		return false
	}
	return x.F49 != nil
}

func (x *TestManyMessageFieldsMessage) HasF50() bool {
	if x == nil {
		return false
	}
	return x.F50 != nil
}

func (x *TestManyMessageFieldsMessage) HasF51() bool {
	if x == nil {
		return false
	}
	return x.F51 != nil
}

func (x *TestManyMessageFieldsMessage) HasF52() bool {
	if x == nil {
		return false
	}
	return x.F52 != nil
}

func (x *TestManyMessageFieldsMessage) HasF53() bool {
	if x == nil {
		return false
	}
	return x.F53 != nil
}

func (x *TestManyMessageFieldsMessage) HasF54() bool {
	if x == nil {
		return false
	}
	return x.F54 != nil
}

func (x *TestManyMessageFieldsMessage) HasF55() bool {
	if x == nil {
		return false
	}
	return x.F55 != nil
}

func (x *TestManyMessageFieldsMessage) HasF56() bool {
	if x == nil {
		return false
	}
	return x.F56 != nil
}

func (x *TestManyMessageFieldsMessage) HasF57() bool {
	if x == nil {
		return false
	}
	return x.F57 != nil
}

func (x *TestManyMessageFieldsMessage) HasF58() bool {
	if x == nil {
		return false
	}
	return x.F58 != nil
}

func (x *TestManyMessageFieldsMessage) HasF59() bool {
	if x == nil {
		return false
	}
	return x.F59 != nil
}

func (x *TestManyMessageFieldsMessage) HasF60() bool {
	if x == nil {
		return false
	}
	return x.F60 != nil
}

func (x *TestManyMessageFieldsMessage) HasF61() bool {
	if x == nil {
		return false
	}
	return x.F61 != nil
}

func (x *TestManyMessageFieldsMessage) HasF62() bool {
	if x == nil {
		return false
	}
	return x.F62 != nil
}

func (x *TestManyMessageFieldsMessage) HasF63() bool {
	if x == nil {
		return false
	}
	return x.F63 != nil
}

func (x *TestManyMessageFieldsMessage) HasF64() bool {
	if x == nil {
		return false
	}
	return x.F64 != nil
}

func (x *TestManyMessageFieldsMessage) HasF65() bool {
	if x == nil {
		return false
	}
	return x.F65 != nil
}

func (x *TestManyMessageFieldsMessage) HasF66() bool {
	if x == nil {
		return false
	}
	return x.F66 != nil
}

func (x *TestManyMessageFieldsMessage) HasF67() bool {
	if x == nil {
		return false
	}
	return x.F67 != nil
}

func (x *TestManyMessageFieldsMessage) HasF68() bool {
	if x == nil {
		return false
	}
	return x.F68 != nil
}

func (x *TestManyMessageFieldsMessage) HasF69() bool {
	if x == nil {
		return false
	}
	return x.F69 != nil
}

func (x *TestManyMessageFieldsMessage) HasF70() bool {
	if x == nil {
		return false
	}
	return x.F70 != nil
}

func (x *TestManyMessageFieldsMessage) HasF71() bool {
	if x == nil {
		return false
	}
	return x.F71 != nil
}

func (x *TestManyMessageFieldsMessage) HasF72() bool {
	if x == nil {
		return false
	}
	return x.F72 != nil
}

func (x *TestManyMessageFieldsMessage) HasF73() bool {
	if x == nil {
		return false
	}
	return x.F73 != nil
}

func (x *TestManyMessageFieldsMessage) HasF74() bool {
	if x == nil {
		return false
	}
	return x.F74 != nil
}

func (x *TestManyMessageFieldsMessage) HasF75() bool {
	if x == nil {
		return false
	}
	return x.F75 != nil
}

func (x *TestManyMessageFieldsMessage) HasF76() bool {
	if x == nil {
		return false
	}
	return x.F76 != nil
}

func (x *TestManyMessageFieldsMessage) HasF77() bool {
	if x == nil {
		return false
	}
	return x.F77 != nil
}

func (x *TestManyMessageFieldsMessage) HasF78() bool {
	if x == nil {
		return false
	}
	return x.F78 != nil
}

func (x *TestManyMessageFieldsMessage) HasF79() bool {
	if x == nil {
		return false
	}
	return x.F79 != nil
}

func (x *TestManyMessageFieldsMessage) HasF80() bool {
	if x == nil {
		return false
	}
	return x.F80 != nil
}

func (x *TestManyMessageFieldsMessage) HasF81() bool {
	if x == nil {
		return false
	}
	return x.F81 != nil
}

func (x *TestManyMessageFieldsMessage) HasF82() bool {
	if x == nil {
		return false
	}
	return x.F82 != nil
}

func (x *TestManyMessageFieldsMessage) HasF83() bool {
	if x == nil {
		return false
	}
	return x.F83 != nil
}

func (x *TestManyMessageFieldsMessage) HasF84() bool {
	if x == nil {
		return false
	}
	return x.F84 != nil
}

func (x *TestManyMessageFieldsMessage) HasF85() bool {
	if x == nil {
		return false
	}
	return x.F85 != nil
}

func (x *TestManyMessageFieldsMessage) HasF86() bool {
	if x == nil {
		return false
	}
	return x.F86 != nil
}

func (x *TestManyMessageFieldsMessage) HasF87() bool {
	if x == nil {
		return false
	}
	return x.F87 != nil
}

func (x *TestManyMessageFieldsMessage) HasF88() bool {
	if x == nil {
		return false
	}
	return x.F88 != nil
}

func (x *TestManyMessageFieldsMessage) HasF89() bool {
	if x == nil {
		return false
	}
	return x.F89 != nil
}

func (x *TestManyMessageFieldsMessage) HasF90() bool {
	if x == nil {
		return false
	}
	return x.F90 != nil
}

func (x *TestManyMessageFieldsMessage) HasF91() bool {
	if x == nil {
		return false
	}
	return x.F91 != nil
}

func (x *TestManyMessageFieldsMessage) HasF92() bool {
	if x == nil {
		return false
	}
	return x.F92 != nil
}

func (x *TestManyMessageFieldsMessage) HasF93() bool {
	if x == nil {
		return false
	}
	return x.F93 != nil
}

func (x *TestManyMessageFieldsMessage) HasF94() bool {
	if x == nil {
		return false
	}
	return x.F94 != nil
}

func (x *TestManyMessageFieldsMessage) HasF95() bool {
	if x == nil {
		return false
	}
	return x.F95 != nil
}

func (x *TestManyMessageFieldsMessage) HasF96() bool {
	if x == nil {
		return false
	}
	return x.F96 != nil
}

func (x *TestManyMessageFieldsMessage) HasF97() bool {
	if x == nil {
		return false
	}
	return x.F97 != nil
}

func (x *TestManyMessageFieldsMessage) HasF98() bool {
	if x == nil {
		return false
	}
	return x.F98 != nil
}

func (x *TestManyMessageFieldsMessage) HasF99() bool {
	if x == nil {
		return false
	}
	return x.F99 != nil
}

func (x *TestManyMessageFieldsMessage) HasF100() bool {
	if x == nil {
		return false
	}
	return x.F100 != nil
}

func (x *TestManyMessageFieldsMessage) ClearF1() {
	x.F1 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF2() {
	x.F2 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF3() {
	x.F3 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF4() {
	x.F4 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF5() {
	x.F5 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF6() {
	x.F6 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF7() {
	x.F7 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF8() {
	x.F8 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF9() {
	x.F9 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF10() {
	x.F10 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF11() {
	x.F11 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF12() {
	x.F12 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF13() {
	x.F13 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF14() {
	x.F14 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF15() {
	x.F15 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF16() {
	x.F16 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF17() {
	x.F17 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF18() {
	x.F18 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF19() {
	x.F19 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF20() {
	x.F20 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF21() {
	x.F21 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF22() {
	x.F22 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF23() {
	x.F23 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF24() {
	x.F24 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF25() {
	x.F25 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF26() {
	x.F26 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF27() {
	x.F27 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF28() {
	x.F28 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF29() {
	x.F29 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF30() {
	x.F30 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF31() {
	x.F31 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF32() {
	x.F32 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF33() {
	x.F33 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF34() {
	x.F34 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF35() {
	x.F35 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF36() {
	x.F36 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF37() {
	x.F37 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF38() {
	x.F38 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF39() {
	x.F39 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF40() {
	x.F40 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF41() {
	x.F41 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF42() {
	x.F42 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF43() {
	x.F43 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF44() {
	x.F44 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF45() {
	x.F45 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF46() {
	x.F46 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF47() {
	x.F47 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF48() {
	x.F48 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF49() {
	x.F49 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF50() {
	x.F50 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF51() {
	x.F51 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF52() {
	x.F52 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF53() {
	x.F53 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF54() {
	x.F54 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF55() {
	x.F55 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF56() {
	x.F56 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF57() {
	x.F57 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF58() {
	x.F58 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF59() {
	x.F59 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF60() {
	x.F60 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF61() {
	x.F61 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF62() {
	x.F62 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF63() {
	x.F63 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF64() {
	x.F64 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF65() {
	x.F65 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF66() {
	x.F66 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF67() {
	x.F67 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF68() {
	x.F68 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF69() {
	x.F69 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF70() {
	x.F70 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF71() {
	x.F71 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF72() {
	x.F72 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF73() {
	x.F73 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF74() {
	x.F74 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF75() {
	x.F75 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF76() {
	x.F76 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF77() {
	x.F77 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF78() {
	x.F78 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF79() {
	x.F79 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF80() {
	x.F80 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF81() {
	x.F81 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF82() {
	x.F82 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF83() {
	x.F83 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF84() {
	x.F84 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF85() {
	x.F85 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF86() {
	x.F86 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF87() {
	x.F87 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF88() {
	x.F88 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF89() {
	x.F89 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF90() {
	x.F90 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF91() {
	x.F91 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF92() {
	x.F92 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF93() {
	x.F93 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF94() {
	x.F94 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF95() {
	x.F95 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF96() {
	x.F96 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF97() {
	x.F97 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF98() {
	x.F98 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF99() {
	x.F99 = nil
}

func (x *TestManyMessageFieldsMessage) ClearF100() {
	x.F100 = nil
}

type TestManyMessageFieldsMessage_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	F1   *TestAllTypes
	F2   *TestAllTypes
	F3   *TestAllTypes
	F4   *TestAllTypes
	F5   *TestAllTypes
	F6   *TestAllTypes
	F7   *TestAllTypes
	F8   *TestAllTypes
	F9   *TestAllTypes
	F10  *TestAllTypes
	F11  *TestAllTypes
	F12  *TestAllTypes
	F13  *TestAllTypes
	F14  *TestAllTypes
	F15  *TestAllTypes
	F16  *TestAllTypes
	F17  *TestAllTypes
	F18  *TestAllTypes
	F19  *TestAllTypes
	F20  *TestAllTypes
	F21  *TestAllTypes
	F22  *TestAllTypes
	F23  *TestAllTypes
	F24  *TestAllTypes
	F25  *TestAllTypes
	F26  *TestAllTypes
	F27  *TestAllTypes
	F28  *TestAllTypes
	F29  *TestAllTypes
	F30  *TestAllTypes
	F31  *TestAllTypes
	F32  *TestAllTypes
	F33  *TestAllTypes
	F34  *TestAllTypes
	F35  *TestAllTypes
	F36  *TestAllTypes
	F37  *TestAllTypes
	F38  *TestAllTypes
	F39  *TestAllTypes
	F40  *TestAllTypes
	F41  *TestAllTypes
	F42  *TestAllTypes
	F43  *TestAllTypes
	F44  *TestAllTypes
	F45  *TestAllTypes
	F46  *TestAllTypes
	F47  *TestAllTypes
	F48  *TestAllTypes
	F49  *TestAllTypes
	F50  *TestAllTypes
	F51  *TestAllTypes
	F52  *TestAllTypes
	F53  *TestAllTypes
	F54  *TestAllTypes
	F55  *TestAllTypes
	F56  *TestAllTypes
	F57  *TestAllTypes
	F58  *TestAllTypes
	F59  *TestAllTypes
	F60  *TestAllTypes
	F61  *TestAllTypes
	F62  *TestAllTypes
	F63  *TestAllTypes
	F64  *TestAllTypes
	F65  *TestAllTypes
	F66  *TestAllTypes
	F67  *TestAllTypes
	F68  *TestAllTypes
	F69  *TestAllTypes
	F70  *TestAllTypes
	F71  *TestAllTypes
	F72  *TestAllTypes
	F73  *TestAllTypes
	F74  *TestAllTypes
	F75  *TestAllTypes
	F76  *TestAllTypes
	F77  *TestAllTypes
	F78  *TestAllTypes
	F79  *TestAllTypes
	F80  *TestAllTypes
	F81  *TestAllTypes
	F82  *TestAllTypes
	F83  *TestAllTypes
	F84  *TestAllTypes
	F85  *TestAllTypes
	F86  *TestAllTypes
	F87  *TestAllTypes
	F88  *TestAllTypes
	F89  *TestAllTypes
	F90  *TestAllTypes
	F91  *TestAllTypes
	F92  *TestAllTypes
	F93  *TestAllTypes
	F94  *TestAllTypes
	F95  *TestAllTypes
	F96  *TestAllTypes
	F97  *TestAllTypes
	F98  *TestAllTypes
	F99  *TestAllTypes
	F100 *TestAllTypes
}

func (b0 TestManyMessageFieldsMessage_builder) Build() *TestManyMessageFieldsMessage {
	m0 := &TestManyMessageFieldsMessage{}
	b, x := &b0, m0
	_, _ = b, x
	x.F1 = b.F1
	x.F2 = b.F2
	x.F3 = b.F3
	x.F4 = b.F4
	x.F5 = b.F5
	x.F6 = b.F6
	x.F7 = b.F7
	x.F8 = b.F8
	x.F9 = b.F9
	x.F10 = b.F10
	x.F11 = b.F11
	x.F12 = b.F12
	x.F13 = b.F13
	x.F14 = b.F14
	x.F15 = b.F15
	x.F16 = b.F16
	x.F17 = b.F17
	x.F18 = b.F18
	x.F19 = b.F19
	x.F20 = b.F20
	x.F21 = b.F21
	x.F22 = b.F22
	x.F23 = b.F23
	x.F24 = b.F24
	x.F25 = b.F25
	x.F26 = b.F26
	x.F27 = b.F27
	x.F28 = b.F28
	x.F29 = b.F29
	x.F30 = b.F30
	x.F31 = b.F31
	x.F32 = b.F32
	x.F33 = b.F33
	x.F34 = b.F34
	x.F35 = b.F35
	x.F36 = b.F36
	x.F37 = b.F37
	x.F38 = b.F38
	x.F39 = b.F39
	x.F40 = b.F40
	x.F41 = b.F41
	x.F42 = b.F42
	x.F43 = b.F43
	x.F44 = b.F44
	x.F45 = b.F45
	x.F46 = b.F46
	x.F47 = b.F47
	x.F48 = b.F48
	x.F49 = b.F49
	x.F50 = b.F50
	x.F51 = b.F51
	x.F52 = b.F52
	x.F53 = b.F53
	x.F54 = b.F54
	x.F55 = b.F55
	x.F56 = b.F56
	x.F57 = b.F57
	x.F58 = b.F58
	x.F59 = b.F59
	x.F60 = b.F60
	x.F61 = b.F61
	x.F62 = b.F62
	x.F63 = b.F63
	x.F64 = b.F64
	x.F65 = b.F65
	x.F66 = b.F66
	x.F67 = b.F67
	x.F68 = b.F68
	x.F69 = b.F69
	x.F70 = b.F70
	x.F71 = b.F71
	x.F72 = b.F72
	x.F73 = b.F73
	x.F74 = b.F74
	x.F75 = b.F75
	x.F76 = b.F76
	x.F77 = b.F77
	x.F78 = b.F78
	x.F79 = b.F79
	x.F80 = b.F80
	x.F81 = b.F81
	x.F82 = b.F82
	x.F83 = b.F83
	x.F84 = b.F84
	x.F85 = b.F85
	x.F86 = b.F86
	x.F87 = b.F87
	x.F88 = b.F88
	x.F89 = b.F89
	x.F90 = b.F90
	x.F91 = b.F91
	x.F92 = b.F92
	x.F93 = b.F93
	x.F94 = b.F94
	x.F95 = b.F95
	x.F96 = b.F96
	x.F97 = b.F97
	x.F98 = b.F98
	x.F99 = b.F99
	x.F100 = b.F100
	return m0
}

type ForeignMessage struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	C             *int32                 `protobuf:"varint,1,opt,name=c" json:"c,omitempty"`
	D             *int32                 `protobuf:"varint,2,opt,name=d" json:"d,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *ForeignMessage) Reset() {
	*x = ForeignMessage{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *ForeignMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*ForeignMessage) ProtoMessage() {}

func (x *ForeignMessage) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *ForeignMessage) GetC() int32 {
	if x != nil && x.C != nil {
		return *x.C
	}
	return 0
}

func (x *ForeignMessage) GetD() int32 {
	if x != nil && x.D != nil {
		return *x.D
	}
	return 0
}

func (x *ForeignMessage) SetC(v int32) {
	x.C = &v
}

func (x *ForeignMessage) SetD(v int32) {
	x.D = &v
}

func (x *ForeignMessage) HasC() bool {
	if x == nil {
		return false
	}
	return x.C != nil
}

func (x *ForeignMessage) HasD() bool {
	if x == nil {
		return false
	}
	return x.D != nil
}

func (x *ForeignMessage) ClearC() {
	x.C = nil
}

func (x *ForeignMessage) ClearD() {
	x.D = nil
}

type ForeignMessage_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	C *int32
	D *int32
}

func (b0 ForeignMessage_builder) Build() *ForeignMessage {
	m0 := &ForeignMessage{}
	b, x := &b0, m0
	_, _ = b, x
	x.C = b.C
	x.D = b.D
	return m0
}

type TestRequired struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	RequiredField *int32                 `protobuf:"varint,1,req,name=required_field,json=requiredField" json:"required_field,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestRequired) Reset() {
	*x = TestRequired{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestRequired) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestRequired) ProtoMessage() {}

func (x *TestRequired) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestRequired) GetRequiredField() int32 {
	if x != nil && x.RequiredField != nil {
		return *x.RequiredField
	}
	return 0
}

func (x *TestRequired) SetRequiredField(v int32) {
	x.RequiredField = &v
}

func (x *TestRequired) HasRequiredField() bool {
	if x == nil {
		return false
	}
	return x.RequiredField != nil
}

func (x *TestRequired) ClearRequiredField() {
	x.RequiredField = nil
}

type TestRequired_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	RequiredField *int32
}

func (b0 TestRequired_builder) Build() *TestRequired {
	m0 := &TestRequired{}
	b, x := &b0, m0
	_, _ = b, x
	x.RequiredField = b.RequiredField
	return m0
}

type TestRequiredForeign struct {
	state           protoimpl.MessageState  `protogen:"hybrid.v1"`
	OptionalMessage *TestRequired           `protobuf:"bytes,1,opt,name=optional_message,json=optionalMessage" json:"optional_message,omitempty"`
	RepeatedMessage []*TestRequired         `protobuf:"bytes,2,rep,name=repeated_message,json=repeatedMessage" json:"repeated_message,omitempty"`
	MapMessage      map[int32]*TestRequired `protobuf:"bytes,3,rep,name=map_message,json=mapMessage" json:"map_message,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Types that are valid to be assigned to OneofField:
	//
	//	*TestRequiredForeign_OneofMessage
	OneofField    isTestRequiredForeign_OneofField `protobuf_oneof:"oneof_field"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestRequiredForeign) Reset() {
	*x = TestRequiredForeign{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestRequiredForeign) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestRequiredForeign) ProtoMessage() {}

func (x *TestRequiredForeign) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[4]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestRequiredForeign) GetOptionalMessage() *TestRequired {
	if x != nil {
		return x.OptionalMessage
	}
	return nil
}

func (x *TestRequiredForeign) GetRepeatedMessage() []*TestRequired {
	if x != nil {
		return x.RepeatedMessage
	}
	return nil
}

func (x *TestRequiredForeign) GetMapMessage() map[int32]*TestRequired {
	if x != nil {
		return x.MapMessage
	}
	return nil
}

func (x *TestRequiredForeign) GetOneofField() isTestRequiredForeign_OneofField {
	if x != nil {
		return x.OneofField
	}
	return nil
}

func (x *TestRequiredForeign) GetOneofMessage() *TestRequired {
	if x != nil {
		if x, ok := x.OneofField.(*TestRequiredForeign_OneofMessage); ok {
			return x.OneofMessage
		}
	}
	return nil
}

func (x *TestRequiredForeign) SetOptionalMessage(v *TestRequired) {
	x.OptionalMessage = v
}

func (x *TestRequiredForeign) SetRepeatedMessage(v []*TestRequired) {
	x.RepeatedMessage = v
}

func (x *TestRequiredForeign) SetMapMessage(v map[int32]*TestRequired) {
	x.MapMessage = v
}

func (x *TestRequiredForeign) SetOneofMessage(v *TestRequired) {
	if v == nil {
		x.OneofField = nil
		return
	}
	x.OneofField = &TestRequiredForeign_OneofMessage{v}
}

func (x *TestRequiredForeign) HasOptionalMessage() bool {
	if x == nil {
		return false
	}
	return x.OptionalMessage != nil
}

func (x *TestRequiredForeign) HasOneofField() bool {
	if x == nil {
		return false
	}
	return x.OneofField != nil
}

func (x *TestRequiredForeign) HasOneofMessage() bool {
	if x == nil {
		return false
	}
	_, ok := x.OneofField.(*TestRequiredForeign_OneofMessage)
	return ok
}

func (x *TestRequiredForeign) ClearOptionalMessage() {
	x.OptionalMessage = nil
}

func (x *TestRequiredForeign) ClearOneofField() {
	x.OneofField = nil
}

func (x *TestRequiredForeign) ClearOneofMessage() {
	if _, ok := x.OneofField.(*TestRequiredForeign_OneofMessage); ok {
		x.OneofField = nil
	}
}

const TestRequiredForeign_OneofField_not_set_case case_TestRequiredForeign_OneofField = 0
const TestRequiredForeign_OneofMessage_case case_TestRequiredForeign_OneofField = 4

func (x *TestRequiredForeign) WhichOneofField() case_TestRequiredForeign_OneofField {
	if x == nil {
		return TestRequiredForeign_OneofField_not_set_case
	}
	switch x.OneofField.(type) {
	case *TestRequiredForeign_OneofMessage:
		return TestRequiredForeign_OneofMessage_case
	default:
		return TestRequiredForeign_OneofField_not_set_case
	}
}

type TestRequiredForeign_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	OptionalMessage *TestRequired
	RepeatedMessage []*TestRequired
	MapMessage      map[int32]*TestRequired
	// Fields of oneof OneofField:
	OneofMessage *TestRequired
	// -- end of OneofField
}

func (b0 TestRequiredForeign_builder) Build() *TestRequiredForeign {
	m0 := &TestRequiredForeign{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptionalMessage = b.OptionalMessage
	x.RepeatedMessage = b.RepeatedMessage
	x.MapMessage = b.MapMessage
	if b.OneofMessage != nil {
		x.OneofField = &TestRequiredForeign_OneofMessage{b.OneofMessage}
	}
	return m0
}

type case_TestRequiredForeign_OneofField protoreflect.FieldNumber

func (x case_TestRequiredForeign_OneofField) String() string {
	md := file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[4].Descriptor()
	if x == 0 {
		return "not set"
	}
	return protoimpl.X.MessageFieldStringOf(md, protoreflect.FieldNumber(x))
}

type isTestRequiredForeign_OneofField interface {
	isTestRequiredForeign_OneofField()
}

type TestRequiredForeign_OneofMessage struct {
	OneofMessage *TestRequired `protobuf:"bytes,4,opt,name=oneof_message,json=oneofMessage,oneof"`
}

func (*TestRequiredForeign_OneofMessage) isTestRequiredForeign_OneofField() {}

type TestRequiredGroupFields struct {
	state         protoimpl.MessageState                   `protogen:"hybrid.v1"`
	Optionalgroup *TestRequiredGroupFields_OptionalGroup   `protobuf:"group,1,opt,name=OptionalGroup,json=optionalgroup" json:"optionalgroup,omitempty"`
	Repeatedgroup []*TestRequiredGroupFields_RepeatedGroup `protobuf:"group,3,rep,name=RepeatedGroup,json=repeatedgroup" json:"repeatedgroup,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestRequiredGroupFields) Reset() {
	*x = TestRequiredGroupFields{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestRequiredGroupFields) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestRequiredGroupFields) ProtoMessage() {}

func (x *TestRequiredGroupFields) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestRequiredGroupFields) GetOptionalgroup() *TestRequiredGroupFields_OptionalGroup {
	if x != nil {
		return x.Optionalgroup
	}
	return nil
}

func (x *TestRequiredGroupFields) GetRepeatedgroup() []*TestRequiredGroupFields_RepeatedGroup {
	if x != nil {
		return x.Repeatedgroup
	}
	return nil
}

func (x *TestRequiredGroupFields) SetOptionalgroup(v *TestRequiredGroupFields_OptionalGroup) {
	x.Optionalgroup = v
}

func (x *TestRequiredGroupFields) SetRepeatedgroup(v []*TestRequiredGroupFields_RepeatedGroup) {
	x.Repeatedgroup = v
}

func (x *TestRequiredGroupFields) HasOptionalgroup() bool {
	if x == nil {
		return false
	}
	return x.Optionalgroup != nil
}

func (x *TestRequiredGroupFields) ClearOptionalgroup() {
	x.Optionalgroup = nil
}

type TestRequiredGroupFields_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Optionalgroup *TestRequiredGroupFields_OptionalGroup
	Repeatedgroup []*TestRequiredGroupFields_RepeatedGroup
}

func (b0 TestRequiredGroupFields_builder) Build() *TestRequiredGroupFields {
	m0 := &TestRequiredGroupFields{}
	b, x := &b0, m0
	_, _ = b, x
	x.Optionalgroup = b.Optionalgroup
	x.Repeatedgroup = b.Repeatedgroup
	return m0
}

type TestRequiredLazy struct {
	state               protoimpl.MessageState `protogen:"hybrid.v1"`
	OptionalLazyMessage *TestRequired          `protobuf:"bytes,1,opt,name=optional_lazy_message,json=optionalLazyMessage" json:"optional_lazy_message,omitempty"`
	unknownFields       protoimpl.UnknownFields
	sizeCache           protoimpl.SizeCache
}

func (x *TestRequiredLazy) Reset() {
	*x = TestRequiredLazy{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestRequiredLazy) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestRequiredLazy) ProtoMessage() {}

func (x *TestRequiredLazy) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestRequiredLazy) GetOptionalLazyMessage() *TestRequired {
	if x != nil {
		return x.OptionalLazyMessage
	}
	return nil
}

func (x *TestRequiredLazy) SetOptionalLazyMessage(v *TestRequired) {
	x.OptionalLazyMessage = v
}

func (x *TestRequiredLazy) HasOptionalLazyMessage() bool {
	if x == nil {
		return false
	}
	return x.OptionalLazyMessage != nil
}

func (x *TestRequiredLazy) ClearOptionalLazyMessage() {
	x.OptionalLazyMessage = nil
}

type TestRequiredLazy_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	OptionalLazyMessage *TestRequired
}

func (b0 TestRequiredLazy_builder) Build() *TestRequiredLazy {
	m0 := &TestRequiredLazy{}
	b, x := &b0, m0
	_, _ = b, x
	x.OptionalLazyMessage = b.OptionalLazyMessage
	return m0
}

type TestPackedTypes struct {
	state          protoimpl.MessageState `protogen:"hybrid.v1"`
	PackedInt32    []int32                `protobuf:"varint,90,rep,packed,name=packed_int32,json=packedInt32" json:"packed_int32,omitempty"`
	PackedInt64    []int64                `protobuf:"varint,91,rep,packed,name=packed_int64,json=packedInt64" json:"packed_int64,omitempty"`
	PackedUint32   []uint32               `protobuf:"varint,92,rep,packed,name=packed_uint32,json=packedUint32" json:"packed_uint32,omitempty"`
	PackedUint64   []uint64               `protobuf:"varint,93,rep,packed,name=packed_uint64,json=packedUint64" json:"packed_uint64,omitempty"`
	PackedSint32   []int32                `protobuf:"zigzag32,94,rep,packed,name=packed_sint32,json=packedSint32" json:"packed_sint32,omitempty"`
	PackedSint64   []int64                `protobuf:"zigzag64,95,rep,packed,name=packed_sint64,json=packedSint64" json:"packed_sint64,omitempty"`
	PackedFixed32  []uint32               `protobuf:"fixed32,96,rep,packed,name=packed_fixed32,json=packedFixed32" json:"packed_fixed32,omitempty"`
	PackedFixed64  []uint64               `protobuf:"fixed64,97,rep,packed,name=packed_fixed64,json=packedFixed64" json:"packed_fixed64,omitempty"`
	PackedSfixed32 []int32                `protobuf:"fixed32,98,rep,packed,name=packed_sfixed32,json=packedSfixed32" json:"packed_sfixed32,omitempty"`
	PackedSfixed64 []int64                `protobuf:"fixed64,99,rep,packed,name=packed_sfixed64,json=packedSfixed64" json:"packed_sfixed64,omitempty"`
	PackedFloat    []float32              `protobuf:"fixed32,100,rep,packed,name=packed_float,json=packedFloat" json:"packed_float,omitempty"`
	PackedDouble   []float64              `protobuf:"fixed64,101,rep,packed,name=packed_double,json=packedDouble" json:"packed_double,omitempty"`
	PackedBool     []bool                 `protobuf:"varint,102,rep,packed,name=packed_bool,json=packedBool" json:"packed_bool,omitempty"`
	PackedEnum     []ForeignEnum          `protobuf:"varint,103,rep,packed,name=packed_enum,json=packedEnum,enum=hybrid.goproto.proto.testeditions.ForeignEnum" json:"packed_enum,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *TestPackedTypes) Reset() {
	*x = TestPackedTypes{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestPackedTypes) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestPackedTypes) ProtoMessage() {}

func (x *TestPackedTypes) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestPackedTypes) GetPackedInt32() []int32 {
	if x != nil {
		return x.PackedInt32
	}
	return nil
}

func (x *TestPackedTypes) GetPackedInt64() []int64 {
	if x != nil {
		return x.PackedInt64
	}
	return nil
}

func (x *TestPackedTypes) GetPackedUint32() []uint32 {
	if x != nil {
		return x.PackedUint32
	}
	return nil
}

func (x *TestPackedTypes) GetPackedUint64() []uint64 {
	if x != nil {
		return x.PackedUint64
	}
	return nil
}

func (x *TestPackedTypes) GetPackedSint32() []int32 {
	if x != nil {
		return x.PackedSint32
	}
	return nil
}

func (x *TestPackedTypes) GetPackedSint64() []int64 {
	if x != nil {
		return x.PackedSint64
	}
	return nil
}

func (x *TestPackedTypes) GetPackedFixed32() []uint32 {
	if x != nil {
		return x.PackedFixed32
	}
	return nil
}

func (x *TestPackedTypes) GetPackedFixed64() []uint64 {
	if x != nil {
		return x.PackedFixed64
	}
	return nil
}

func (x *TestPackedTypes) GetPackedSfixed32() []int32 {
	if x != nil {
		return x.PackedSfixed32
	}
	return nil
}

func (x *TestPackedTypes) GetPackedSfixed64() []int64 {
	if x != nil {
		return x.PackedSfixed64
	}
	return nil
}

func (x *TestPackedTypes) GetPackedFloat() []float32 {
	if x != nil {
		return x.PackedFloat
	}
	return nil
}

func (x *TestPackedTypes) GetPackedDouble() []float64 {
	if x != nil {
		return x.PackedDouble
	}
	return nil
}

func (x *TestPackedTypes) GetPackedBool() []bool {
	if x != nil {
		return x.PackedBool
	}
	return nil
}

func (x *TestPackedTypes) GetPackedEnum() []ForeignEnum {
	if x != nil {
		return x.PackedEnum
	}
	return nil
}

func (x *TestPackedTypes) SetPackedInt32(v []int32) {
	x.PackedInt32 = v
}

func (x *TestPackedTypes) SetPackedInt64(v []int64) {
	x.PackedInt64 = v
}

func (x *TestPackedTypes) SetPackedUint32(v []uint32) {
	x.PackedUint32 = v
}

func (x *TestPackedTypes) SetPackedUint64(v []uint64) {
	x.PackedUint64 = v
}

func (x *TestPackedTypes) SetPackedSint32(v []int32) {
	x.PackedSint32 = v
}

func (x *TestPackedTypes) SetPackedSint64(v []int64) {
	x.PackedSint64 = v
}

func (x *TestPackedTypes) SetPackedFixed32(v []uint32) {
	x.PackedFixed32 = v
}

func (x *TestPackedTypes) SetPackedFixed64(v []uint64) {
	x.PackedFixed64 = v
}

func (x *TestPackedTypes) SetPackedSfixed32(v []int32) {
	x.PackedSfixed32 = v
}

func (x *TestPackedTypes) SetPackedSfixed64(v []int64) {
	x.PackedSfixed64 = v
}

func (x *TestPackedTypes) SetPackedFloat(v []float32) {
	x.PackedFloat = v
}

func (x *TestPackedTypes) SetPackedDouble(v []float64) {
	x.PackedDouble = v
}

func (x *TestPackedTypes) SetPackedBool(v []bool) {
	x.PackedBool = v
}

func (x *TestPackedTypes) SetPackedEnum(v []ForeignEnum) {
	x.PackedEnum = v
}

type TestPackedTypes_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	PackedInt32    []int32
	PackedInt64    []int64
	PackedUint32   []uint32
	PackedUint64   []uint64
	PackedSint32   []int32
	PackedSint64   []int64
	PackedFixed32  []uint32
	PackedFixed64  []uint64
	PackedSfixed32 []int32
	PackedSfixed64 []int64
	PackedFloat    []float32
	PackedDouble   []float64
	PackedBool     []bool
	PackedEnum     []ForeignEnum
}

func (b0 TestPackedTypes_builder) Build() *TestPackedTypes {
	m0 := &TestPackedTypes{}
	b, x := &b0, m0
	_, _ = b, x
	x.PackedInt32 = b.PackedInt32
	x.PackedInt64 = b.PackedInt64
	x.PackedUint32 = b.PackedUint32
	x.PackedUint64 = b.PackedUint64
	x.PackedSint32 = b.PackedSint32
	x.PackedSint64 = b.PackedSint64
	x.PackedFixed32 = b.PackedFixed32
	x.PackedFixed64 = b.PackedFixed64
	x.PackedSfixed32 = b.PackedSfixed32
	x.PackedSfixed64 = b.PackedSfixed64
	x.PackedFloat = b.PackedFloat
	x.PackedDouble = b.PackedDouble
	x.PackedBool = b.PackedBool
	x.PackedEnum = b.PackedEnum
	return m0
}

type TestPackedExtensions struct {
	state           protoimpl.MessageState `protogen:"hybrid.v1"`
	extensionFields protoimpl.ExtensionFields
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *TestPackedExtensions) Reset() {
	*x = TestPackedExtensions{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestPackedExtensions) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestPackedExtensions) ProtoMessage() {}

func (x *TestPackedExtensions) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

type TestPackedExtensions_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

}

func (b0 TestPackedExtensions_builder) Build() *TestPackedExtensions {
	m0 := &TestPackedExtensions{}
	b, x := &b0, m0
	_, _ = b, x
	return m0
}

type RemoteDefault struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	Default       *enums_hybrid.Enum     `protobuf:"varint,1,opt,name=default,enum=hybrid.goproto.proto.enums.Enum" json:"default,omitempty"`
	Zero          *enums_hybrid.Enum     `protobuf:"varint,2,opt,name=zero,enum=hybrid.goproto.proto.enums.Enum,def=0" json:"zero,omitempty"`
	One           *enums_hybrid.Enum     `protobuf:"varint,3,opt,name=one,enum=hybrid.goproto.proto.enums.Enum,def=1" json:"one,omitempty"`
	Elevent       *enums_hybrid.Enum     `protobuf:"varint,4,opt,name=elevent,enum=hybrid.goproto.proto.enums.Enum,def=11" json:"elevent,omitempty"`
	Seventeen     *enums_hybrid.Enum     `protobuf:"varint,5,opt,name=seventeen,enum=hybrid.goproto.proto.enums.Enum,def=17" json:"seventeen,omitempty"`
	Thirtyseven   *enums_hybrid.Enum     `protobuf:"varint,6,opt,name=thirtyseven,enum=hybrid.goproto.proto.enums.Enum,def=37" json:"thirtyseven,omitempty"`
	Sixtyseven    *enums_hybrid.Enum     `protobuf:"varint,7,opt,name=sixtyseven,enum=hybrid.goproto.proto.enums.Enum,def=67" json:"sixtyseven,omitempty"`
	Negative      *enums_hybrid.Enum     `protobuf:"varint,8,opt,name=negative,enum=hybrid.goproto.proto.enums.Enum,def=-1" json:"negative,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

// Default values for RemoteDefault fields.
const (
	Default_RemoteDefault_Zero        = enums_hybrid.Enum(0)  // enums_hybrid.Enum_ZERO
	Default_RemoteDefault_One         = enums_hybrid.Enum(1)  // enums_hybrid.Enum_ONE
	Default_RemoteDefault_Elevent     = enums_hybrid.Enum(11) // enums_hybrid.Enum_ELEVENT
	Default_RemoteDefault_Seventeen   = enums_hybrid.Enum(17) // enums_hybrid.Enum_SEVENTEEN
	Default_RemoteDefault_Thirtyseven = enums_hybrid.Enum(37) // enums_hybrid.Enum_THIRTYSEVEN
	Default_RemoteDefault_Sixtyseven  = enums_hybrid.Enum(67) // enums_hybrid.Enum_SIXTYSEVEN
	Default_RemoteDefault_Negative    = enums_hybrid.Enum(-1) // enums_hybrid.Enum_NEGATIVE
)

func (x *RemoteDefault) Reset() {
	*x = RemoteDefault{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *RemoteDefault) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*RemoteDefault) ProtoMessage() {}

func (x *RemoteDefault) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *RemoteDefault) GetDefault() enums_hybrid.Enum {
	if x != nil && x.Default != nil {
		return *x.Default
	}
	return enums_hybrid.Enum(1337)
}

func (x *RemoteDefault) GetZero() enums_hybrid.Enum {
	if x != nil && x.Zero != nil {
		return *x.Zero
	}
	return Default_RemoteDefault_Zero
}

func (x *RemoteDefault) GetOne() enums_hybrid.Enum {
	if x != nil && x.One != nil {
		return *x.One
	}
	return Default_RemoteDefault_One
}

func (x *RemoteDefault) GetElevent() enums_hybrid.Enum {
	if x != nil && x.Elevent != nil {
		return *x.Elevent
	}
	return Default_RemoteDefault_Elevent
}

func (x *RemoteDefault) GetSeventeen() enums_hybrid.Enum {
	if x != nil && x.Seventeen != nil {
		return *x.Seventeen
	}
	return Default_RemoteDefault_Seventeen
}

func (x *RemoteDefault) GetThirtyseven() enums_hybrid.Enum {
	if x != nil && x.Thirtyseven != nil {
		return *x.Thirtyseven
	}
	return Default_RemoteDefault_Thirtyseven
}

func (x *RemoteDefault) GetSixtyseven() enums_hybrid.Enum {
	if x != nil && x.Sixtyseven != nil {
		return *x.Sixtyseven
	}
	return Default_RemoteDefault_Sixtyseven
}

func (x *RemoteDefault) GetNegative() enums_hybrid.Enum {
	if x != nil && x.Negative != nil {
		return *x.Negative
	}
	return Default_RemoteDefault_Negative
}

func (x *RemoteDefault) SetDefault(v enums_hybrid.Enum) {
	x.Default = &v
}

func (x *RemoteDefault) SetZero(v enums_hybrid.Enum) {
	x.Zero = &v
}

func (x *RemoteDefault) SetOne(v enums_hybrid.Enum) {
	x.One = &v
}

func (x *RemoteDefault) SetElevent(v enums_hybrid.Enum) {
	x.Elevent = &v
}

func (x *RemoteDefault) SetSeventeen(v enums_hybrid.Enum) {
	x.Seventeen = &v
}

func (x *RemoteDefault) SetThirtyseven(v enums_hybrid.Enum) {
	x.Thirtyseven = &v
}

func (x *RemoteDefault) SetSixtyseven(v enums_hybrid.Enum) {
	x.Sixtyseven = &v
}

func (x *RemoteDefault) SetNegative(v enums_hybrid.Enum) {
	x.Negative = &v
}

func (x *RemoteDefault) HasDefault() bool {
	if x == nil {
		return false
	}
	return x.Default != nil
}

func (x *RemoteDefault) HasZero() bool {
	if x == nil {
		return false
	}
	return x.Zero != nil
}

func (x *RemoteDefault) HasOne() bool {
	if x == nil {
		return false
	}
	return x.One != nil
}

func (x *RemoteDefault) HasElevent() bool {
	if x == nil {
		return false
	}
	return x.Elevent != nil
}

func (x *RemoteDefault) HasSeventeen() bool {
	if x == nil {
		return false
	}
	return x.Seventeen != nil
}

func (x *RemoteDefault) HasThirtyseven() bool {
	if x == nil {
		return false
	}
	return x.Thirtyseven != nil
}

func (x *RemoteDefault) HasSixtyseven() bool {
	if x == nil {
		return false
	}
	return x.Sixtyseven != nil
}

func (x *RemoteDefault) HasNegative() bool {
	if x == nil {
		return false
	}
	return x.Negative != nil
}

func (x *RemoteDefault) ClearDefault() {
	x.Default = nil
}

func (x *RemoteDefault) ClearZero() {
	x.Zero = nil
}

func (x *RemoteDefault) ClearOne() {
	x.One = nil
}

func (x *RemoteDefault) ClearElevent() {
	x.Elevent = nil
}

func (x *RemoteDefault) ClearSeventeen() {
	x.Seventeen = nil
}

func (x *RemoteDefault) ClearThirtyseven() {
	x.Thirtyseven = nil
}

func (x *RemoteDefault) ClearSixtyseven() {
	x.Sixtyseven = nil
}

func (x *RemoteDefault) ClearNegative() {
	x.Negative = nil
}

type RemoteDefault_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	Default     *enums_hybrid.Enum
	Zero        *enums_hybrid.Enum
	One         *enums_hybrid.Enum
	Elevent     *enums_hybrid.Enum
	Seventeen   *enums_hybrid.Enum
	Thirtyseven *enums_hybrid.Enum
	Sixtyseven  *enums_hybrid.Enum
	Negative    *enums_hybrid.Enum
}

func (b0 RemoteDefault_builder) Build() *RemoteDefault {
	m0 := &RemoteDefault{}
	b, x := &b0, m0
	_, _ = b, x
	x.Default = b.Default
	x.Zero = b.Zero
	x.One = b.One
	x.Elevent = b.Elevent
	x.Seventeen = b.Seventeen
	x.Thirtyseven = b.Thirtyseven
	x.Sixtyseven = b.Sixtyseven
	x.Negative = b.Negative
	return m0
}

type TestAllTypes_NestedMessage struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	A             *int32                 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
	Corecursive   *TestAllTypes          `protobuf:"bytes,2,opt,name=corecursive" json:"corecursive,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestAllTypes_NestedMessage) Reset() {
	*x = TestAllTypes_NestedMessage{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestAllTypes_NestedMessage) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestAllTypes_NestedMessage) ProtoMessage() {}

func (x *TestAllTypes_NestedMessage) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestAllTypes_NestedMessage) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *TestAllTypes_NestedMessage) GetCorecursive() *TestAllTypes {
	if x != nil {
		return x.Corecursive
	}
	return nil
}

func (x *TestAllTypes_NestedMessage) SetA(v int32) {
	x.A = &v
}

func (x *TestAllTypes_NestedMessage) SetCorecursive(v *TestAllTypes) {
	x.Corecursive = v
}

func (x *TestAllTypes_NestedMessage) HasA() bool {
	if x == nil {
		return false
	}
	return x.A != nil
}

func (x *TestAllTypes_NestedMessage) HasCorecursive() bool {
	if x == nil {
		return false
	}
	return x.Corecursive != nil
}

func (x *TestAllTypes_NestedMessage) ClearA() {
	x.A = nil
}

func (x *TestAllTypes_NestedMessage) ClearCorecursive() {
	x.Corecursive = nil
}

type TestAllTypes_NestedMessage_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	A           *int32
	Corecursive *TestAllTypes
}

func (b0 TestAllTypes_NestedMessage_builder) Build() *TestAllTypes_NestedMessage {
	m0 := &TestAllTypes_NestedMessage{}
	b, x := &b0, m0
	_, _ = b, x
	x.A = b.A
	x.Corecursive = b.Corecursive
	return m0
}

type TestAllTypes_OptionalGroup struct {
	state                 protoimpl.MessageState      `protogen:"hybrid.v1"`
	A                     *int32                      `protobuf:"varint,17,opt,name=a" json:"a,omitempty"`
	OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,1000,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
	SameFieldNumber       *int32                      `protobuf:"varint,16,opt,name=same_field_number,json=sameFieldNumber" json:"same_field_number,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *TestAllTypes_OptionalGroup) Reset() {
	*x = TestAllTypes_OptionalGroup{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestAllTypes_OptionalGroup) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestAllTypes_OptionalGroup) ProtoMessage() {}

func (x *TestAllTypes_OptionalGroup) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestAllTypes_OptionalGroup) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *TestAllTypes_OptionalGroup) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
	if x != nil {
		return x.OptionalNestedMessage
	}
	return nil
}

func (x *TestAllTypes_OptionalGroup) GetSameFieldNumber() int32 {
	if x != nil && x.SameFieldNumber != nil {
		return *x.SameFieldNumber
	}
	return 0
}

func (x *TestAllTypes_OptionalGroup) SetA(v int32) {
	x.A = &v
}

func (x *TestAllTypes_OptionalGroup) SetOptionalNestedMessage(v *TestAllTypes_NestedMessage) {
	x.OptionalNestedMessage = v
}

func (x *TestAllTypes_OptionalGroup) SetSameFieldNumber(v int32) {
	x.SameFieldNumber = &v
}

func (x *TestAllTypes_OptionalGroup) HasA() bool {
	if x == nil {
		return false
	}
	return x.A != nil
}

func (x *TestAllTypes_OptionalGroup) HasOptionalNestedMessage() bool {
	if x == nil {
		return false
	}
	return x.OptionalNestedMessage != nil
}

func (x *TestAllTypes_OptionalGroup) HasSameFieldNumber() bool {
	if x == nil {
		return false
	}
	return x.SameFieldNumber != nil
}

func (x *TestAllTypes_OptionalGroup) ClearA() {
	x.A = nil
}

func (x *TestAllTypes_OptionalGroup) ClearOptionalNestedMessage() {
	x.OptionalNestedMessage = nil
}

func (x *TestAllTypes_OptionalGroup) ClearSameFieldNumber() {
	x.SameFieldNumber = nil
}

type TestAllTypes_OptionalGroup_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	A                     *int32
	OptionalNestedMessage *TestAllTypes_NestedMessage
	SameFieldNumber       *int32
}

func (b0 TestAllTypes_OptionalGroup_builder) Build() *TestAllTypes_OptionalGroup {
	m0 := &TestAllTypes_OptionalGroup{}
	b, x := &b0, m0
	_, _ = b, x
	x.A = b.A
	x.OptionalNestedMessage = b.OptionalNestedMessage
	x.SameFieldNumber = b.SameFieldNumber
	return m0
}

type TestAllTypes_RepeatedGroup struct {
	state                 protoimpl.MessageState      `protogen:"hybrid.v1"`
	A                     *int32                      `protobuf:"varint,47,opt,name=a" json:"a,omitempty"`
	OptionalNestedMessage *TestAllTypes_NestedMessage `protobuf:"bytes,1001,opt,name=optional_nested_message,json=optionalNestedMessage" json:"optional_nested_message,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *TestAllTypes_RepeatedGroup) Reset() {
	*x = TestAllTypes_RepeatedGroup{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestAllTypes_RepeatedGroup) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestAllTypes_RepeatedGroup) ProtoMessage() {}

func (x *TestAllTypes_RepeatedGroup) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestAllTypes_RepeatedGroup) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *TestAllTypes_RepeatedGroup) GetOptionalNestedMessage() *TestAllTypes_NestedMessage {
	if x != nil {
		return x.OptionalNestedMessage
	}
	return nil
}

func (x *TestAllTypes_RepeatedGroup) SetA(v int32) {
	x.A = &v
}

func (x *TestAllTypes_RepeatedGroup) SetOptionalNestedMessage(v *TestAllTypes_NestedMessage) {
	x.OptionalNestedMessage = v
}

func (x *TestAllTypes_RepeatedGroup) HasA() bool {
	if x == nil {
		return false
	}
	return x.A != nil
}

func (x *TestAllTypes_RepeatedGroup) HasOptionalNestedMessage() bool {
	if x == nil {
		return false
	}
	return x.OptionalNestedMessage != nil
}

func (x *TestAllTypes_RepeatedGroup) ClearA() {
	x.A = nil
}

func (x *TestAllTypes_RepeatedGroup) ClearOptionalNestedMessage() {
	x.OptionalNestedMessage = nil
}

type TestAllTypes_RepeatedGroup_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	A                     *int32
	OptionalNestedMessage *TestAllTypes_NestedMessage
}

func (b0 TestAllTypes_RepeatedGroup_builder) Build() *TestAllTypes_RepeatedGroup {
	m0 := &TestAllTypes_RepeatedGroup{}
	b, x := &b0, m0
	_, _ = b, x
	x.A = b.A
	x.OptionalNestedMessage = b.OptionalNestedMessage
	return m0
}

type TestAllTypes_OneofGroup struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	A             *int32                 `protobuf:"varint,1,opt,name=a" json:"a,omitempty"`
	B             *int32                 `protobuf:"varint,2,opt,name=b" json:"b,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestAllTypes_OneofGroup) Reset() {
	*x = TestAllTypes_OneofGroup{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[30]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestAllTypes_OneofGroup) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestAllTypes_OneofGroup) ProtoMessage() {}

func (x *TestAllTypes_OneofGroup) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[30]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestAllTypes_OneofGroup) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *TestAllTypes_OneofGroup) GetB() int32 {
	if x != nil && x.B != nil {
		return *x.B
	}
	return 0
}

func (x *TestAllTypes_OneofGroup) SetA(v int32) {
	x.A = &v
}

func (x *TestAllTypes_OneofGroup) SetB(v int32) {
	x.B = &v
}

func (x *TestAllTypes_OneofGroup) HasA() bool {
	if x == nil {
		return false
	}
	return x.A != nil
}

func (x *TestAllTypes_OneofGroup) HasB() bool {
	if x == nil {
		return false
	}
	return x.B != nil
}

func (x *TestAllTypes_OneofGroup) ClearA() {
	x.A = nil
}

func (x *TestAllTypes_OneofGroup) ClearB() {
	x.B = nil
}

type TestAllTypes_OneofGroup_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	A *int32
	B *int32
}

func (b0 TestAllTypes_OneofGroup_builder) Build() *TestAllTypes_OneofGroup {
	m0 := &TestAllTypes_OneofGroup{}
	b, x := &b0, m0
	_, _ = b, x
	x.A = b.A
	x.B = b.B
	return m0
}

type TestRequiredGroupFields_OptionalGroup struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	A             *int32                 `protobuf:"varint,2,req,name=a" json:"a,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestRequiredGroupFields_OptionalGroup) Reset() {
	*x = TestRequiredGroupFields_OptionalGroup{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[32]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestRequiredGroupFields_OptionalGroup) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestRequiredGroupFields_OptionalGroup) ProtoMessage() {}

func (x *TestRequiredGroupFields_OptionalGroup) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[32]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestRequiredGroupFields_OptionalGroup) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *TestRequiredGroupFields_OptionalGroup) SetA(v int32) {
	x.A = &v
}

func (x *TestRequiredGroupFields_OptionalGroup) HasA() bool {
	if x == nil {
		return false
	}
	return x.A != nil
}

func (x *TestRequiredGroupFields_OptionalGroup) ClearA() {
	x.A = nil
}

type TestRequiredGroupFields_OptionalGroup_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	A *int32
}

func (b0 TestRequiredGroupFields_OptionalGroup_builder) Build() *TestRequiredGroupFields_OptionalGroup {
	m0 := &TestRequiredGroupFields_OptionalGroup{}
	b, x := &b0, m0
	_, _ = b, x
	x.A = b.A
	return m0
}

type TestRequiredGroupFields_RepeatedGroup struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	A             *int32                 `protobuf:"varint,4,req,name=a" json:"a,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestRequiredGroupFields_RepeatedGroup) Reset() {
	*x = TestRequiredGroupFields_RepeatedGroup{}
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[33]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *TestRequiredGroupFields_RepeatedGroup) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*TestRequiredGroupFields_RepeatedGroup) ProtoMessage() {}

func (x *TestRequiredGroupFields_RepeatedGroup) ProtoReflect() protoreflect.Message {
	mi := &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[33]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

func (x *TestRequiredGroupFields_RepeatedGroup) GetA() int32 {
	if x != nil && x.A != nil {
		return *x.A
	}
	return 0
}

func (x *TestRequiredGroupFields_RepeatedGroup) SetA(v int32) {
	x.A = &v
}

func (x *TestRequiredGroupFields_RepeatedGroup) HasA() bool {
	if x == nil {
		return false
	}
	return x.A != nil
}

func (x *TestRequiredGroupFields_RepeatedGroup) ClearA() {
	x.A = nil
}

type TestRequiredGroupFields_RepeatedGroup_builder struct {
	_ [0]func() // Prevents comparability and use of unkeyed literals for the builder.

	A *int32
}

func (b0 TestRequiredGroupFields_RepeatedGroup_builder) Build() *TestRequiredGroupFields_RepeatedGroup {
	m0 := &TestRequiredGroupFields_RepeatedGroup{}
	b, x := &b0, m0
	_, _ = b, x
	x.A = b.A
	return m0
}

var file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes = []protoimpl.ExtensionInfo{
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]int32)(nil),
		Field:         90,
		Name:          "hybrid.goproto.proto.testeditions.packed_int32",
		Tag:           "varint,90,rep,packed,name=packed_int32",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]int64)(nil),
		Field:         91,
		Name:          "hybrid.goproto.proto.testeditions.packed_int64",
		Tag:           "varint,91,rep,packed,name=packed_int64",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]uint32)(nil),
		Field:         92,
		Name:          "hybrid.goproto.proto.testeditions.packed_uint32",
		Tag:           "varint,92,rep,packed,name=packed_uint32",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]uint64)(nil),
		Field:         93,
		Name:          "hybrid.goproto.proto.testeditions.packed_uint64",
		Tag:           "varint,93,rep,packed,name=packed_uint64",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]int32)(nil),
		Field:         94,
		Name:          "hybrid.goproto.proto.testeditions.packed_sint32",
		Tag:           "zigzag32,94,rep,packed,name=packed_sint32",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]int64)(nil),
		Field:         95,
		Name:          "hybrid.goproto.proto.testeditions.packed_sint64",
		Tag:           "zigzag64,95,rep,packed,name=packed_sint64",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]uint32)(nil),
		Field:         96,
		Name:          "hybrid.goproto.proto.testeditions.packed_fixed32",
		Tag:           "fixed32,96,rep,packed,name=packed_fixed32",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]uint64)(nil),
		Field:         97,
		Name:          "hybrid.goproto.proto.testeditions.packed_fixed64",
		Tag:           "fixed64,97,rep,packed,name=packed_fixed64",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]int32)(nil),
		Field:         98,
		Name:          "hybrid.goproto.proto.testeditions.packed_sfixed32",
		Tag:           "fixed32,98,rep,packed,name=packed_sfixed32",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]int64)(nil),
		Field:         99,
		Name:          "hybrid.goproto.proto.testeditions.packed_sfixed64",
		Tag:           "fixed64,99,rep,packed,name=packed_sfixed64",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]float32)(nil),
		Field:         100,
		Name:          "hybrid.goproto.proto.testeditions.packed_float",
		Tag:           "fixed32,100,rep,packed,name=packed_float",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]float64)(nil),
		Field:         101,
		Name:          "hybrid.goproto.proto.testeditions.packed_double",
		Tag:           "fixed64,101,rep,packed,name=packed_double",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]bool)(nil),
		Field:         102,
		Name:          "hybrid.goproto.proto.testeditions.packed_bool",
		Tag:           "varint,102,rep,packed,name=packed_bool",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
	{
		ExtendedType:  (*TestPackedExtensions)(nil),
		ExtensionType: ([]ForeignEnum)(nil),
		Field:         103,
		Name:          "hybrid.goproto.proto.testeditions.packed_enum",
		Tag:           "varint,103,rep,packed,name=packed_enum,enum=hybrid.goproto.proto.testeditions.ForeignEnum",
		Filename:      "internal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto",
	},
}

// Extension fields to TestPackedExtensions.
var (
	// repeated int32 packed_int32 = 90;
	E_PackedInt32 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[0]
	// repeated int64 packed_int64 = 91;
	E_PackedInt64 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[1]
	// repeated uint32 packed_uint32 = 92;
	E_PackedUint32 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[2]
	// repeated uint64 packed_uint64 = 93;
	E_PackedUint64 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[3]
	// repeated sint32 packed_sint32 = 94;
	E_PackedSint32 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[4]
	// repeated sint64 packed_sint64 = 95;
	E_PackedSint64 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[5]
	// repeated fixed32 packed_fixed32 = 96;
	E_PackedFixed32 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[6]
	// repeated fixed64 packed_fixed64 = 97;
	E_PackedFixed64 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[7]
	// repeated sfixed32 packed_sfixed32 = 98;
	E_PackedSfixed32 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[8]
	// repeated sfixed64 packed_sfixed64 = 99;
	E_PackedSfixed64 = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[9]
	// repeated float packed_float = 100;
	E_PackedFloat = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[10]
	// repeated double packed_double = 101;
	E_PackedDouble = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[11]
	// repeated bool packed_bool = 102;
	E_PackedBool = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[12]
	// repeated hybrid.goproto.proto.testeditions.ForeignEnum packed_enum = 103;
	E_PackedEnum = &file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes[13]
)

var File_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto protoreflect.FileDescriptor

const file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_rawDesc = "" +
	"\n" +
	"Finternal/testprotos/testeditions/testeditions_hybrid/test.hybrid.proto\x12!hybrid.goproto.proto.testeditions\x1a9internal/testprotos/enums/enums_hybrid/enums.hybrid.proto\x1aMinternal/testprotos/testeditions/testeditions_hybrid/test_import.hybrid.proto\x1a!google/protobuf/go_features.proto\"\xd0I\n" +
	"\fTestAllTypes\x12,\n" +
	"\x0esingular_int32\x18| \x01(\x05B\x05\xaa\x01\x02\b\x02R\rsingularInt32\x12,\n" +
	"\x0esingular_int64\x18} \x01(\x03B\x05\xaa\x01\x02\b\x02R\rsingularInt64\x12.\n" +
	"\x0fsingular_uint32\x18~ \x01(\rB\x05\xaa\x01\x02\b\x02R\x0esingularUint32\x12.\n" +
	"\x0fsingular_uint64\x18\x7f \x01(\x04B\x05\xaa\x01\x02\b\x02R\x0esingularUint64\x12/\n" +
	"\x0fsingular_sint32\x18\x80\x01 \x01(\x11B\x05\xaa\x01\x02\b\x02R\x0esingularSint32\x12/\n" +
	"\x0fsingular_sint64\x18\x81\x01 \x01(\x12B\x05\xaa\x01\x02\b\x02R\x0esingularSint64\x121\n" +
	"\x10singular_fixed32\x18\x82\x01 \x01(\aB\x05\xaa\x01\x02\b\x02R\x0fsingularFixed32\x121\n" +
	"\x10singular_fixed64\x18\x83\x01 \x01(\x06B\x05\xaa\x01\x02\b\x02R\x0fsingularFixed64\x123\n" +
	"\x11singular_sfixed32\x18\x84\x01 \x01(\x0fB\x05\xaa\x01\x02\b\x02R\x10singularSfixed32\x123\n" +
	"\x11singular_sfixed64\x18\x85\x01 \x01(\x10B\x05\xaa\x01\x02\b\x02R\x10singularSfixed64\x12-\n" +
	"\x0esingular_float\x18\x86\x01 \x01(\x02B\x05\xaa\x01\x02\b\x02R\rsingularFloat\x12/\n" +
	"\x0fsingular_double\x18\x87\x01 \x01(\x01B\x05\xaa\x01\x02\b\x02R\x0esingularDouble\x12+\n" +
	"\rsingular_bool\x18\x88\x01 \x01(\bB\x05\xaa\x01\x02\b\x02R\fsingularBool\x12/\n" +
	"\x0fsingular_string\x18\x89\x01 \x01(\tB\x05\xaa\x01\x02\b\x02R\x0esingularString\x12-\n" +
	"\x0esingular_bytes\x18\x8a\x01 \x01(\fB\x05\xaa\x01\x02\b\x02R\rsingularBytes\x12t\n" +
	"\x14singular_nested_enum\x18\x8e\x01 \x01(\x0e2:.hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnumB\x05\xaa\x01\x02\b\x02R\x12singularNestedEnum\x12j\n" +
	"\x15singular_foreign_enum\x18\x8f\x01 \x01(\x0e2..hybrid.goproto.proto.testeditions.ForeignEnumB\x05\xaa\x01\x02\b\x02R\x13singularForeignEnum\x12g\n" +
	"\x14singular_import_enum\x18\x90\x01 \x01(\x0e2-.hybrid.goproto.proto.testeditions.ImportEnumB\x05\xaa\x01\x02\b\x02R\x12singularImportEnum\x12%\n" +
	"\x0eoptional_int32\x18\x01 \x01(\x05R\roptionalInt32\x12%\n" +
	"\x0eoptional_int64\x18\x02 \x01(\x03R\roptionalInt64\x12'\n" +
	"\x0foptional_uint32\x18\x03 \x01(\rR\x0eoptionalUint32\x12'\n" +
	"\x0foptional_uint64\x18\x04 \x01(\x04R\x0eoptionalUint64\x12'\n" +
	"\x0foptional_sint32\x18\x05 \x01(\x11R\x0eoptionalSint32\x12'\n" +
	"\x0foptional_sint64\x18\x06 \x01(\x12R\x0eoptionalSint64\x12)\n" +
	"\x10optional_fixed32\x18\a \x01(\aR\x0foptionalFixed32\x12)\n" +
	"\x10optional_fixed64\x18\b \x01(\x06R\x0foptionalFixed64\x12+\n" +
	"\x11optional_sfixed32\x18\t \x01(\x0fR\x10optionalSfixed32\x12+\n" +
	"\x11optional_sfixed64\x18\n" +
	" \x01(\x10R\x10optionalSfixed64\x12%\n" +
	"\x0eoptional_float\x18\v \x01(\x02R\roptionalFloat\x12'\n" +
	"\x0foptional_double\x18\f \x01(\x01R\x0eoptionalDouble\x12#\n" +
	"\roptional_bool\x18\r \x01(\bR\foptionalBool\x12'\n" +
	"\x0foptional_string\x18\x0e \x01(\tR\x0eoptionalString\x12%\n" +
	"\x0eoptional_bytes\x18\x0f \x01(\fR\roptionalBytes\x12j\n" +
	"\roptionalgroup\x18\x10 \x01(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.OptionalGroupB\x05\xaa\x01\x02(\x02R\roptionalgroup\x12}\n" +
	"\x18not_group_like_delimited\x18\x11 \x01(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.OptionalGroupB\x05\xaa\x01\x02(\x02R\x15notGroupLikeDelimited\x12u\n" +
	"\x17optional_nested_message\x18\x12 \x01(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessageR\x15optionalNestedMessage\x12k\n" +
	"\x18optional_foreign_message\x18\x13 \x01(\v21.hybrid.goproto.proto.testeditions.ForeignMessageR\x16optionalForeignMessage\x12h\n" +
	"\x17optional_import_message\x18\x14 \x01(\v20.hybrid.goproto.proto.testeditions.ImportMessageR\x15optionalImportMessage\x12l\n" +
	"\x14optional_nested_enum\x18\x15 \x01(\x0e2:.hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnumR\x12optionalNestedEnum\x12b\n" +
	"\x15optional_foreign_enum\x18\x16 \x01(\x0e2..hybrid.goproto.proto.testeditions.ForeignEnumR\x13optionalForeignEnum\x12_\n" +
	"\x14optional_import_enum\x18\x17 \x01(\x0e2-.hybrid.goproto.proto.testeditions.ImportEnumR\x12optionalImportEnum\x12\x82\x01\n" +
	"\x1coptional_lazy_nested_message\x18\x18 \x01(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessageB\x02(\x01R\x19optionalLazyNestedMessage\x12%\n" +
	"\x0erepeated_int32\x18\x1f \x03(\x05R\rrepeatedInt32\x12%\n" +
	"\x0erepeated_int64\x18  \x03(\x03R\rrepeatedInt64\x12'\n" +
	"\x0frepeated_uint32\x18! \x03(\rR\x0erepeatedUint32\x12'\n" +
	"\x0frepeated_uint64\x18\" \x03(\x04R\x0erepeatedUint64\x12'\n" +
	"\x0frepeated_sint32\x18# \x03(\x11R\x0erepeatedSint32\x12'\n" +
	"\x0frepeated_sint64\x18$ \x03(\x12R\x0erepeatedSint64\x12)\n" +
	"\x10repeated_fixed32\x18% \x03(\aR\x0frepeatedFixed32\x12)\n" +
	"\x10repeated_fixed64\x18& \x03(\x06R\x0frepeatedFixed64\x12+\n" +
	"\x11repeated_sfixed32\x18' \x03(\x0fR\x10repeatedSfixed32\x12+\n" +
	"\x11repeated_sfixed64\x18( \x03(\x10R\x10repeatedSfixed64\x12%\n" +
	"\x0erepeated_float\x18) \x03(\x02R\rrepeatedFloat\x12'\n" +
	"\x0frepeated_double\x18* \x03(\x01R\x0erepeatedDouble\x12#\n" +
	"\rrepeated_bool\x18+ \x03(\bR\frepeatedBool\x12'\n" +
	"\x0frepeated_string\x18, \x03(\tR\x0erepeatedString\x12%\n" +
	"\x0erepeated_bytes\x18- \x03(\fR\rrepeatedBytes\x12l\n" +
	"\rrepeatedgroup\x18. \x03(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.RepeatedGroupB\a\xaa\x01\x04\x18\x02(\x02R\rrepeatedgroup\x12u\n" +
	"\x17repeated_nested_message\x180 \x03(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessageR\x15repeatedNestedMessage\x12k\n" +
	"\x18repeated_foreign_message\x181 \x03(\v21.hybrid.goproto.proto.testeditions.ForeignMessageR\x16repeatedForeignMessage\x12g\n" +
	"\x16repeated_importmessage\x182 \x03(\v20.hybrid.goproto.proto.testeditions.ImportMessageR\x15repeatedImportmessage\x12l\n" +
	"\x14repeated_nested_enum\x183 \x03(\x0e2:.hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnumR\x12repeatedNestedEnum\x12b\n" +
	"\x15repeated_foreign_enum\x184 \x03(\x0e2..hybrid.goproto.proto.testeditions.ForeignEnumR\x13repeatedForeignEnum\x12^\n" +
	"\x13repeated_importenum\x185 \x03(\x0e2-.hybrid.goproto.proto.testeditions.ImportEnumR\x12repeatedImportenum\x12j\n" +
	"\x0fmap_int32_int32\x188 \x03(\v2B.hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32Int32EntryR\rmapInt32Int32\x12j\n" +
	"\x0fmap_int64_int64\x189 \x03(\v2B.hybrid.goproto.proto.testeditions.TestAllTypes.MapInt64Int64EntryR\rmapInt64Int64\x12p\n" +
	"\x11map_uint32_uint32\x18: \x03(\v2D.hybrid.goproto.proto.testeditions.TestAllTypes.MapUint32Uint32EntryR\x0fmapUint32Uint32\x12p\n" +
	"\x11map_uint64_uint64\x18; \x03(\v2D.hybrid.goproto.proto.testeditions.TestAllTypes.MapUint64Uint64EntryR\x0fmapUint64Uint64\x12p\n" +
	"\x11map_sint32_sint32\x18< \x03(\v2D.hybrid.goproto.proto.testeditions.TestAllTypes.MapSint32Sint32EntryR\x0fmapSint32Sint32\x12p\n" +
	"\x11map_sint64_sint64\x18= \x03(\v2D.hybrid.goproto.proto.testeditions.TestAllTypes.MapSint64Sint64EntryR\x0fmapSint64Sint64\x12v\n" +
	"\x13map_fixed32_fixed32\x18> \x03(\v2F.hybrid.goproto.proto.testeditions.TestAllTypes.MapFixed32Fixed32EntryR\x11mapFixed32Fixed32\x12v\n" +
	"\x13map_fixed64_fixed64\x18? \x03(\v2F.hybrid.goproto.proto.testeditions.TestAllTypes.MapFixed64Fixed64EntryR\x11mapFixed64Fixed64\x12|\n" +
	"\x15map_sfixed32_sfixed32\x18@ \x03(\v2H.hybrid.goproto.proto.testeditions.TestAllTypes.MapSfixed32Sfixed32EntryR\x13mapSfixed32Sfixed32\x12|\n" +
	"\x15map_sfixed64_sfixed64\x18A \x03(\v2H.hybrid.goproto.proto.testeditions.TestAllTypes.MapSfixed64Sfixed64EntryR\x13mapSfixed64Sfixed64\x12j\n" +
	"\x0fmap_int32_float\x18B \x03(\v2B.hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32FloatEntryR\rmapInt32Float\x12m\n" +
	"\x10map_int32_double\x18C \x03(\v2C.hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32DoubleEntryR\x0emapInt32Double\x12d\n" +
	"\rmap_bool_bool\x18D \x03(\v2@.hybrid.goproto.proto.testeditions.TestAllTypes.MapBoolBoolEntryR\vmapBoolBool\x12p\n" +
	"\x11map_string_string\x18E \x03(\v2D.hybrid.goproto.proto.testeditions.TestAllTypes.MapStringStringEntryR\x0fmapStringString\x12m\n" +
	"\x10map_string_bytes\x18F \x03(\v2C.hybrid.goproto.proto.testeditions.TestAllTypes.MapStringBytesEntryR\x0emapStringBytes\x12\x86\x01\n" +
	"\x19map_string_nested_message\x18G \x03(\v2K.hybrid.goproto.proto.testeditions.TestAllTypes.MapStringNestedMessageEntryR\x16mapStringNestedMessage\x12}\n" +
	"\x16map_string_nested_enum\x18I \x03(\v2H.hybrid.goproto.proto.testeditions.TestAllTypes.MapStringNestedEnumEntryR\x13mapStringNestedEnum\x12'\n" +
	"\rdefault_int32\x18Q \x01(\x05:\x0281R\fdefaultInt32\x12'\n" +
	"\rdefault_int64\x18R \x01(\x03:\x0282R\fdefaultInt64\x12)\n" +
	"\x0edefault_uint32\x18S \x01(\r:\x0283R\rdefaultUint32\x12)\n" +
	"\x0edefault_uint64\x18T \x01(\x04:\x0284R\rdefaultUint64\x12*\n" +
	"\x0edefault_sint32\x18U \x01(\x11:\x03-85R\rdefaultSint32\x12)\n" +
	"\x0edefault_sint64\x18V \x01(\x12:\x0286R\rdefaultSint64\x12+\n" +
	"\x0fdefault_fixed32\x18W \x01(\a:\x0287R\x0edefaultFixed32\x12+\n" +
	"\x0fdefault_fixed64\x18X \x01(\x06:\x0288R\x0edefaultFixed64\x12-\n" +
	"\x10default_sfixed32\x18Y \x01(\x0f:\x0289R\x0fdefaultSfixed32\x12.\n" +
	"\x10default_sfixed64\x18P \x01(\x10:\x03-90R\x0fdefaultSfixed64\x12)\n" +
	"\rdefault_float\x18[ \x01(\x02:\x0491.5R\fdefaultFloat\x12,\n" +
	"\x0edefault_double\x18\\ \x01(\x01:\x0592000R\rdefaultDouble\x12'\n" +
	"\fdefault_bool\x18] \x01(\b:\x04trueR\vdefaultBool\x12,\n" +
	"\x0edefault_string\x18^ \x01(\t:\x05helloR\rdefaultString\x12*\n" +
	"\rdefault_bytes\x18_ \x01(\f:\x05worldR\fdefaultBytes\x12o\n" +
	"\x13default_nested_enum\x18` \x01(\x0e2:.hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnum:\x03BARR\x11defaultNestedEnum\x12m\n" +
	"\x14default_foreign_enum\x18a \x01(\x0e2..hybrid.goproto.proto.testeditions.ForeignEnum:\vFOREIGN_BARR\x12defaultForeignEnum\x12#\n" +
	"\foneof_uint32\x18o \x01(\rH\x00R\voneofUint32\x12q\n" +
	"\x14oneof_nested_message\x18p \x01(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessageH\x00R\x12oneofNestedMessage\x12#\n" +
	"\foneof_string\x18q \x01(\tH\x00R\voneofString\x12!\n" +
	"\voneof_bytes\x18r \x01(\fH\x00R\n" +
	"oneofBytes\x12\x1f\n" +
	"\n" +
	"oneof_bool\x18s \x01(\bH\x00R\toneofBool\x12#\n" +
	"\foneof_uint64\x18t \x01(\x04H\x00R\voneofUint64\x12!\n" +
	"\voneof_float\x18u \x01(\x02H\x00R\n" +
	"oneofFloat\x12#\n" +
	"\foneof_double\x18v \x01(\x01H\x00R\voneofDouble\x12[\n" +
	"\n" +
	"oneof_enum\x18w \x01(\x0e2:.hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnumH\x00R\toneofEnum\x12c\n" +
	"\n" +
	"oneofgroup\x18y \x01(\v2:.hybrid.goproto.proto.testeditions.TestAllTypes.OneofGroupB\x05\xaa\x01\x02(\x02H\x00R\n" +
	"oneofgroup\x124\n" +
	"\x15oneof_optional_uint32\x18x \x01(\rH\x01R\x13oneofOptionalUint32\x1ap\n" +
	"\rNestedMessage\x12\f\n" +
	"\x01a\x18\x01 \x01(\x05R\x01a\x12Q\n" +
	"\vcorecursive\x18\x02 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\vcorecursive\x1a\xc1\x01\n" +
	"\rOptionalGroup\x12\f\n" +
	"\x01a\x18\x11 \x01(\x05R\x01a\x12v\n" +
	"\x17optional_nested_message\x18\xe8\a \x01(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessageR\x15optionalNestedMessage\x12*\n" +
	"\x11same_field_number\x18\x10 \x01(\x05R\x0fsameFieldNumber\x1a\x95\x01\n" +
	"\rRepeatedGroup\x12\f\n" +
	"\x01a\x18/ \x01(\x05R\x01a\x12v\n" +
	"\x17optional_nested_message\x18\xe9\a \x01(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessageR\x15optionalNestedMessage\x1a@\n" +
	"\x12MapInt32Int32Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x05R\x05value:\x028\x01\x1a@\n" +
	"\x12MapInt64Int64Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x03R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x03R\x05value:\x028\x01\x1aB\n" +
	"\x14MapUint32Uint32Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\rR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\rR\x05value:\x028\x01\x1aB\n" +
	"\x14MapUint64Uint64Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x04R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x04R\x05value:\x028\x01\x1aB\n" +
	"\x14MapSint32Sint32Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x11R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x11R\x05value:\x028\x01\x1aB\n" +
	"\x14MapSint64Sint64Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x12R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x12R\x05value:\x028\x01\x1aD\n" +
	"\x16MapFixed32Fixed32Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\aR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\aR\x05value:\x028\x01\x1aD\n" +
	"\x16MapFixed64Fixed64Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x06R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x06R\x05value:\x028\x01\x1aF\n" +
	"\x18MapSfixed32Sfixed32Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x0fR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x0fR\x05value:\x028\x01\x1aF\n" +
	"\x18MapSfixed64Sfixed64Entry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x10R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x10R\x05value:\x028\x01\x1a@\n" +
	"\x12MapInt32FloatEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x02R\x05value:\x028\x01\x1aA\n" +
	"\x13MapInt32DoubleEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\x01R\x05value:\x028\x01\x1a>\n" +
	"\x10MapBoolBoolEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\bR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\bR\x05value:\x028\x01\x1aB\n" +
	"\x14MapStringStringEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1aA\n" +
	"\x13MapStringBytesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\fR\x05value:\x028\x01\x1a\x88\x01\n" +
	"\x1bMapStringNestedMessageEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12S\n" +
	"\x05value\x18\x02 \x01(\v2=.hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessageR\x05value:\x028\x01\x1a\x82\x01\n" +
	"\x18MapStringNestedEnumEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12P\n" +
	"\x05value\x18\x02 \x01(\x0e2:.hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnumR\x05value:\x028\x01\x1a(\n" +
	"\n" +
	"OneofGroup\x12\f\n" +
	"\x01a\x18\x01 \x01(\x05R\x01a\x12\f\n" +
	"\x01b\x18\x02 \x01(\x05R\x01b\"9\n" +
	"\n" +
	"NestedEnum\x12\a\n" +
	"\x03FOO\x10\x00\x12\a\n" +
	"\x03BAR\x10\x01\x12\a\n" +
	"\x03BAZ\x10\x02\x12\x10\n" +
	"\x03NEG\x10\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01B\r\n" +
	"\voneof_fieldB\x10\n" +
	"\x0eoneof_optional\"\xba4\n" +
	"\x1cTestManyMessageFieldsMessage\x12?\n" +
	"\x02f1\x18\x01 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f1\x12?\n" +
	"\x02f2\x18\x02 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f2\x12?\n" +
	"\x02f3\x18\x03 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f3\x12?\n" +
	"\x02f4\x18\x04 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f4\x12?\n" +
	"\x02f5\x18\x05 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f5\x12?\n" +
	"\x02f6\x18\x06 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f6\x12?\n" +
	"\x02f7\x18\a \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f7\x12?\n" +
	"\x02f8\x18\b \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f8\x12?\n" +
	"\x02f9\x18\t \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x02f9\x12A\n" +
	"\x03f10\x18\n" +
	" \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f10\x12A\n" +
	"\x03f11\x18\v \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f11\x12A\n" +
	"\x03f12\x18\f \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f12\x12A\n" +
	"\x03f13\x18\r \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f13\x12A\n" +
	"\x03f14\x18\x0e \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f14\x12A\n" +
	"\x03f15\x18\x0f \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f15\x12A\n" +
	"\x03f16\x18\x10 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f16\x12A\n" +
	"\x03f17\x18\x11 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f17\x12A\n" +
	"\x03f18\x18\x12 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f18\x12A\n" +
	"\x03f19\x18\x13 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f19\x12A\n" +
	"\x03f20\x18\x14 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f20\x12A\n" +
	"\x03f21\x18\x15 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f21\x12A\n" +
	"\x03f22\x18\x16 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f22\x12A\n" +
	"\x03f23\x18\x17 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f23\x12A\n" +
	"\x03f24\x18\x18 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f24\x12A\n" +
	"\x03f25\x18\x19 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f25\x12A\n" +
	"\x03f26\x18\x1a \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f26\x12A\n" +
	"\x03f27\x18\x1b \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f27\x12A\n" +
	"\x03f28\x18\x1c \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f28\x12A\n" +
	"\x03f29\x18\x1d \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f29\x12A\n" +
	"\x03f30\x18\x1e \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f30\x12A\n" +
	"\x03f31\x18\x1f \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f31\x12A\n" +
	"\x03f32\x18  \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f32\x12A\n" +
	"\x03f33\x18! \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f33\x12A\n" +
	"\x03f34\x18\" \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f34\x12A\n" +
	"\x03f35\x18# \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f35\x12A\n" +
	"\x03f36\x18$ \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f36\x12A\n" +
	"\x03f37\x18% \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f37\x12A\n" +
	"\x03f38\x18& \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f38\x12A\n" +
	"\x03f39\x18' \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f39\x12A\n" +
	"\x03f40\x18( \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f40\x12A\n" +
	"\x03f41\x18) \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f41\x12A\n" +
	"\x03f42\x18* \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f42\x12A\n" +
	"\x03f43\x18+ \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f43\x12A\n" +
	"\x03f44\x18, \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f44\x12A\n" +
	"\x03f45\x18- \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f45\x12A\n" +
	"\x03f46\x18. \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f46\x12A\n" +
	"\x03f47\x18/ \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f47\x12A\n" +
	"\x03f48\x180 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f48\x12A\n" +
	"\x03f49\x181 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f49\x12A\n" +
	"\x03f50\x182 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f50\x12A\n" +
	"\x03f51\x183 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f51\x12A\n" +
	"\x03f52\x184 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f52\x12A\n" +
	"\x03f53\x185 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f53\x12A\n" +
	"\x03f54\x186 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f54\x12A\n" +
	"\x03f55\x187 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f55\x12A\n" +
	"\x03f56\x188 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f56\x12A\n" +
	"\x03f57\x189 \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f57\x12A\n" +
	"\x03f58\x18: \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f58\x12A\n" +
	"\x03f59\x18; \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f59\x12A\n" +
	"\x03f60\x18< \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f60\x12A\n" +
	"\x03f61\x18= \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f61\x12A\n" +
	"\x03f62\x18> \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f62\x12A\n" +
	"\x03f63\x18? \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f63\x12A\n" +
	"\x03f64\x18@ \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f64\x12A\n" +
	"\x03f65\x18A \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f65\x12A\n" +
	"\x03f66\x18B \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f66\x12A\n" +
	"\x03f67\x18C \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f67\x12A\n" +
	"\x03f68\x18D \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f68\x12A\n" +
	"\x03f69\x18E \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f69\x12A\n" +
	"\x03f70\x18F \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f70\x12A\n" +
	"\x03f71\x18G \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f71\x12A\n" +
	"\x03f72\x18H \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f72\x12A\n" +
	"\x03f73\x18I \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f73\x12A\n" +
	"\x03f74\x18J \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f74\x12A\n" +
	"\x03f75\x18K \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f75\x12A\n" +
	"\x03f76\x18L \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f76\x12A\n" +
	"\x03f77\x18M \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f77\x12A\n" +
	"\x03f78\x18N \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f78\x12A\n" +
	"\x03f79\x18O \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f79\x12A\n" +
	"\x03f80\x18P \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f80\x12A\n" +
	"\x03f81\x18Q \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f81\x12A\n" +
	"\x03f82\x18R \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f82\x12A\n" +
	"\x03f83\x18S \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f83\x12A\n" +
	"\x03f84\x18T \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f84\x12A\n" +
	"\x03f85\x18U \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f85\x12A\n" +
	"\x03f86\x18V \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f86\x12A\n" +
	"\x03f87\x18W \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f87\x12A\n" +
	"\x03f88\x18X \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f88\x12A\n" +
	"\x03f89\x18Y \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f89\x12A\n" +
	"\x03f90\x18Z \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f90\x12A\n" +
	"\x03f91\x18[ \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f91\x12A\n" +
	"\x03f92\x18\\ \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f92\x12A\n" +
	"\x03f93\x18] \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f93\x12A\n" +
	"\x03f94\x18^ \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f94\x12A\n" +
	"\x03f95\x18_ \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f95\x12A\n" +
	"\x03f96\x18` \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f96\x12A\n" +
	"\x03f97\x18a \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f97\x12A\n" +
	"\x03f98\x18b \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f98\x12A\n" +
	"\x03f99\x18c \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x03f99\x12C\n" +
	"\x04f100\x18d \x01(\v2/.hybrid.goproto.proto.testeditions.TestAllTypesR\x04f100\",\n" +
	"\x0eForeignMessage\x12\f\n" +
	"\x01c\x18\x01 \x01(\x05R\x01c\x12\f\n" +
	"\x01d\x18\x02 \x01(\x05R\x01d\"<\n" +
	"\fTestRequired\x12,\n" +
	"\x0erequired_field\x18\x01 \x01(\x05B\x05\xaa\x01\x02\b\x03R\rrequiredField\"\x8d\x04\n" +
	"\x13TestRequiredForeign\x12Z\n" +
	"\x10optional_message\x18\x01 \x01(\v2/.hybrid.goproto.proto.testeditions.TestRequiredR\x0foptionalMessage\x12Z\n" +
	"\x10repeated_message\x18\x02 \x03(\v2/.hybrid.goproto.proto.testeditions.TestRequiredR\x0frepeatedMessage\x12g\n" +
	"\vmap_message\x18\x03 \x03(\v2F.hybrid.goproto.proto.testeditions.TestRequiredForeign.MapMessageEntryR\n" +
	"mapMessage\x12V\n" +
	"\roneof_message\x18\x04 \x01(\v2/.hybrid.goproto.proto.testeditions.TestRequiredH\x00R\foneofMessage\x1an\n" +
	"\x0fMapMessageEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\x05R\x03key\x12E\n" +
	"\x05value\x18\x02 \x01(\v2/.hybrid.goproto.proto.testeditions.TestRequiredR\x05value:\x028\x01B\r\n" +
	"\voneof_field\"\xd3\x02\n" +
	"\x17TestRequiredGroupFields\x12u\n" +
	"\roptionalgroup\x18\x01 \x01(\v2H.hybrid.goproto.proto.testeditions.TestRequiredGroupFields.OptionalGroupB\x05\xaa\x01\x02(\x02R\roptionalgroup\x12u\n" +
	"\rrepeatedgroup\x18\x03 \x03(\v2H.hybrid.goproto.proto.testeditions.TestRequiredGroupFields.RepeatedGroupB\x05\xaa\x01\x02(\x02R\rrepeatedgroup\x1a$\n" +
	"\rOptionalGroup\x12\x13\n" +
	"\x01a\x18\x02 \x01(\x05B\x05\xaa\x01\x02\b\x03R\x01a\x1a$\n" +
	"\rRepeatedGroup\x12\x13\n" +
	"\x01a\x18\x04 \x01(\x05B\x05\xaa\x01\x02\b\x03R\x01a\"{\n" +
	"\x10TestRequiredLazy\x12g\n" +
	"\x15optional_lazy_message\x18\x01 \x01(\v2/.hybrid.goproto.proto.testeditions.TestRequiredB\x02(\x01R\x13optionalLazyMessage\"\xa7\x05\n" +
	"\x0fTestPackedTypes\x12(\n" +
	"\fpacked_int32\x18Z \x03(\x05B\x05\xaa\x01\x02\x18\x01R\vpackedInt32\x12(\n" +
	"\fpacked_int64\x18[ \x03(\x03B\x05\xaa\x01\x02\x18\x01R\vpackedInt64\x12*\n" +
	"\rpacked_uint32\x18\\ \x03(\rB\x05\xaa\x01\x02\x18\x01R\fpackedUint32\x12*\n" +
	"\rpacked_uint64\x18] \x03(\x04B\x05\xaa\x01\x02\x18\x01R\fpackedUint64\x12*\n" +
	"\rpacked_sint32\x18^ \x03(\x11B\x05\xaa\x01\x02\x18\x01R\fpackedSint32\x12*\n" +
	"\rpacked_sint64\x18_ \x03(\x12B\x05\xaa\x01\x02\x18\x01R\fpackedSint64\x12,\n" +
	"\x0epacked_fixed32\x18` \x03(\aB\x05\xaa\x01\x02\x18\x01R\rpackedFixed32\x12,\n" +
	"\x0epacked_fixed64\x18a \x03(\x06B\x05\xaa\x01\x02\x18\x01R\rpackedFixed64\x12.\n" +
	"\x0fpacked_sfixed32\x18b \x03(\x0fB\x05\xaa\x01\x02\x18\x01R\x0epackedSfixed32\x12.\n" +
	"\x0fpacked_sfixed64\x18c \x03(\x10B\x05\xaa\x01\x02\x18\x01R\x0epackedSfixed64\x12(\n" +
	"\fpacked_float\x18d \x03(\x02B\x05\xaa\x01\x02\x18\x01R\vpackedFloat\x12*\n" +
	"\rpacked_double\x18e \x03(\x01B\x05\xaa\x01\x02\x18\x01R\fpackedDouble\x12&\n" +
	"\vpacked_bool\x18f \x03(\bB\x05\xaa\x01\x02\x18\x01R\n" +
	"packedBool\x12V\n" +
	"\vpacked_enum\x18g \x03(\x0e2..hybrid.goproto.proto.testeditions.ForeignEnumB\x05\xaa\x01\x02\x18\x01R\n" +
	"packedEnum\" \n" +
	"\x14TestPackedExtensions*\b\b\x01\x10\x80\x80\x80\x80\x02\"\xb7\x04\n" +
	"\rRemoteDefault\x12:\n" +
	"\adefault\x18\x01 \x01(\x0e2 .hybrid.goproto.proto.enums.EnumR\adefault\x12:\n" +
	"\x04zero\x18\x02 \x01(\x0e2 .hybrid.goproto.proto.enums.Enum:\x04ZEROR\x04zero\x127\n" +
	"\x03one\x18\x03 \x01(\x0e2 .hybrid.goproto.proto.enums.Enum:\x03ONER\x03one\x12C\n" +
	"\aelevent\x18\x04 \x01(\x0e2 .hybrid.goproto.proto.enums.Enum:\aELEVENTR\aelevent\x12I\n" +
	"\tseventeen\x18\x05 \x01(\x0e2 .hybrid.goproto.proto.enums.Enum:\tSEVENTEENR\tseventeen\x12O\n" +
	"\vthirtyseven\x18\x06 \x01(\x0e2 .hybrid.goproto.proto.enums.Enum:\vTHIRTYSEVENR\vthirtyseven\x12L\n" +
	"\n" +
	"sixtyseven\x18\a \x01(\x0e2 .hybrid.goproto.proto.enums.Enum:\n" +
	"SIXTYSEVENR\n" +
	"sixtyseven\x12F\n" +
	"\bnegative\x18\b \x01(\x0e2 .hybrid.goproto.proto.enums.Enum:\bNEGATIVER\bnegative*R\n" +
	"\vForeignEnum\x12\x10\n" +
	"\fFOREIGN_ZERO\x10\x00\x12\x0f\n" +
	"\vFOREIGN_FOO\x10\x04\x12\x0f\n" +
	"\vFOREIGN_BAR\x10\x05\x12\x0f\n" +
	"\vFOREIGN_BAZ\x10\x06:a\n" +
	"\fpacked_int32\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18Z \x03(\x05B\x05\xaa\x01\x02\x18\x01R\vpackedInt32:a\n" +
	"\fpacked_int64\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18[ \x03(\x03B\x05\xaa\x01\x02\x18\x01R\vpackedInt64:c\n" +
	"\rpacked_uint32\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18\\ \x03(\rB\x05\xaa\x01\x02\x18\x01R\fpackedUint32:c\n" +
	"\rpacked_uint64\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18] \x03(\x04B\x05\xaa\x01\x02\x18\x01R\fpackedUint64:c\n" +
	"\rpacked_sint32\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18^ \x03(\x11B\x05\xaa\x01\x02\x18\x01R\fpackedSint32:c\n" +
	"\rpacked_sint64\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18_ \x03(\x12B\x05\xaa\x01\x02\x18\x01R\fpackedSint64:e\n" +
	"\x0epacked_fixed32\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18` \x03(\aB\x05\xaa\x01\x02\x18\x01R\rpackedFixed32:e\n" +
	"\x0epacked_fixed64\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18a \x03(\x06B\x05\xaa\x01\x02\x18\x01R\rpackedFixed64:g\n" +
	"\x0fpacked_sfixed32\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18b \x03(\x0fB\x05\xaa\x01\x02\x18\x01R\x0epackedSfixed32:g\n" +
	"\x0fpacked_sfixed64\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18c \x03(\x10B\x05\xaa\x01\x02\x18\x01R\x0epackedSfixed64:a\n" +
	"\fpacked_float\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18d \x03(\x02B\x05\xaa\x01\x02\x18\x01R\vpackedFloat:c\n" +
	"\rpacked_double\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18e \x03(\x01B\x05\xaa\x01\x02\x18\x01R\fpackedDouble:_\n" +
	"\vpacked_bool\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18f \x03(\bB\x05\xaa\x01\x02\x18\x01R\n" +
	"packedBool:\x8f\x01\n" +
	"\vpacked_enum\x127.hybrid.goproto.proto.testeditions.TestPackedExtensions\x18g \x03(\x0e2..hybrid.goproto.proto.testeditions.ForeignEnumB\x05\xaa\x01\x02\x18\x01R\n" +
	"packedEnumBYZOgoogle.golang.org/protobuf/internal/testprotos/testeditions/testeditions_hybrid\x92\x03\x05\xd2>\x02\x10\x02b\beditionsp\xe8\a"

var file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes = make([]protoimpl.MessageInfo, 34)
var file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_goTypes = []any{
	(ForeignEnum)(0),                     // 0: hybrid.goproto.proto.testeditions.ForeignEnum
	(TestAllTypes_NestedEnum)(0),         // 1: hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnum
	(*TestAllTypes)(nil),                 // 2: hybrid.goproto.proto.testeditions.TestAllTypes
	(*TestManyMessageFieldsMessage)(nil), // 3: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage
	(*ForeignMessage)(nil),               // 4: hybrid.goproto.proto.testeditions.ForeignMessage
	(*TestRequired)(nil),                 // 5: hybrid.goproto.proto.testeditions.TestRequired
	(*TestRequiredForeign)(nil),          // 6: hybrid.goproto.proto.testeditions.TestRequiredForeign
	(*TestRequiredGroupFields)(nil),      // 7: hybrid.goproto.proto.testeditions.TestRequiredGroupFields
	(*TestRequiredLazy)(nil),             // 8: hybrid.goproto.proto.testeditions.TestRequiredLazy
	(*TestPackedTypes)(nil),              // 9: hybrid.goproto.proto.testeditions.TestPackedTypes
	(*TestPackedExtensions)(nil),         // 10: hybrid.goproto.proto.testeditions.TestPackedExtensions
	(*RemoteDefault)(nil),                // 11: hybrid.goproto.proto.testeditions.RemoteDefault
	(*TestAllTypes_NestedMessage)(nil),   // 12: hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage
	(*TestAllTypes_OptionalGroup)(nil),   // 13: hybrid.goproto.proto.testeditions.TestAllTypes.OptionalGroup
	(*TestAllTypes_RepeatedGroup)(nil),   // 14: hybrid.goproto.proto.testeditions.TestAllTypes.RepeatedGroup
	nil,                                  // 15: hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32Int32Entry
	nil,                                  // 16: hybrid.goproto.proto.testeditions.TestAllTypes.MapInt64Int64Entry
	nil,                                  // 17: hybrid.goproto.proto.testeditions.TestAllTypes.MapUint32Uint32Entry
	nil,                                  // 18: hybrid.goproto.proto.testeditions.TestAllTypes.MapUint64Uint64Entry
	nil,                                  // 19: hybrid.goproto.proto.testeditions.TestAllTypes.MapSint32Sint32Entry
	nil,                                  // 20: hybrid.goproto.proto.testeditions.TestAllTypes.MapSint64Sint64Entry
	nil,                                  // 21: hybrid.goproto.proto.testeditions.TestAllTypes.MapFixed32Fixed32Entry
	nil,                                  // 22: hybrid.goproto.proto.testeditions.TestAllTypes.MapFixed64Fixed64Entry
	nil,                                  // 23: hybrid.goproto.proto.testeditions.TestAllTypes.MapSfixed32Sfixed32Entry
	nil,                                  // 24: hybrid.goproto.proto.testeditions.TestAllTypes.MapSfixed64Sfixed64Entry
	nil,                                  // 25: hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32FloatEntry
	nil,                                  // 26: hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32DoubleEntry
	nil,                                  // 27: hybrid.goproto.proto.testeditions.TestAllTypes.MapBoolBoolEntry
	nil,                                  // 28: hybrid.goproto.proto.testeditions.TestAllTypes.MapStringStringEntry
	nil,                                  // 29: hybrid.goproto.proto.testeditions.TestAllTypes.MapStringBytesEntry
	nil,                                  // 30: hybrid.goproto.proto.testeditions.TestAllTypes.MapStringNestedMessageEntry
	nil,                                  // 31: hybrid.goproto.proto.testeditions.TestAllTypes.MapStringNestedEnumEntry
	(*TestAllTypes_OneofGroup)(nil),      // 32: hybrid.goproto.proto.testeditions.TestAllTypes.OneofGroup
	nil,                                  // 33: hybrid.goproto.proto.testeditions.TestRequiredForeign.MapMessageEntry
	(*TestRequiredGroupFields_OptionalGroup)(nil), // 34: hybrid.goproto.proto.testeditions.TestRequiredGroupFields.OptionalGroup
	(*TestRequiredGroupFields_RepeatedGroup)(nil), // 35: hybrid.goproto.proto.testeditions.TestRequiredGroupFields.RepeatedGroup
	(ImportEnum)(0),        // 36: hybrid.goproto.proto.testeditions.ImportEnum
	(*ImportMessage)(nil),  // 37: hybrid.goproto.proto.testeditions.ImportMessage
	(enums_hybrid.Enum)(0), // 38: hybrid.goproto.proto.enums.Enum
}
var file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_depIdxs = []int32{
	1,   // 0: hybrid.goproto.proto.testeditions.TestAllTypes.singular_nested_enum:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnum
	0,   // 1: hybrid.goproto.proto.testeditions.TestAllTypes.singular_foreign_enum:type_name -> hybrid.goproto.proto.testeditions.ForeignEnum
	36,  // 2: hybrid.goproto.proto.testeditions.TestAllTypes.singular_import_enum:type_name -> hybrid.goproto.proto.testeditions.ImportEnum
	13,  // 3: hybrid.goproto.proto.testeditions.TestAllTypes.optionalgroup:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.OptionalGroup
	13,  // 4: hybrid.goproto.proto.testeditions.TestAllTypes.not_group_like_delimited:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.OptionalGroup
	12,  // 5: hybrid.goproto.proto.testeditions.TestAllTypes.optional_nested_message:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage
	4,   // 6: hybrid.goproto.proto.testeditions.TestAllTypes.optional_foreign_message:type_name -> hybrid.goproto.proto.testeditions.ForeignMessage
	37,  // 7: hybrid.goproto.proto.testeditions.TestAllTypes.optional_import_message:type_name -> hybrid.goproto.proto.testeditions.ImportMessage
	1,   // 8: hybrid.goproto.proto.testeditions.TestAllTypes.optional_nested_enum:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnum
	0,   // 9: hybrid.goproto.proto.testeditions.TestAllTypes.optional_foreign_enum:type_name -> hybrid.goproto.proto.testeditions.ForeignEnum
	36,  // 10: hybrid.goproto.proto.testeditions.TestAllTypes.optional_import_enum:type_name -> hybrid.goproto.proto.testeditions.ImportEnum
	12,  // 11: hybrid.goproto.proto.testeditions.TestAllTypes.optional_lazy_nested_message:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage
	14,  // 12: hybrid.goproto.proto.testeditions.TestAllTypes.repeatedgroup:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.RepeatedGroup
	12,  // 13: hybrid.goproto.proto.testeditions.TestAllTypes.repeated_nested_message:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage
	4,   // 14: hybrid.goproto.proto.testeditions.TestAllTypes.repeated_foreign_message:type_name -> hybrid.goproto.proto.testeditions.ForeignMessage
	37,  // 15: hybrid.goproto.proto.testeditions.TestAllTypes.repeated_importmessage:type_name -> hybrid.goproto.proto.testeditions.ImportMessage
	1,   // 16: hybrid.goproto.proto.testeditions.TestAllTypes.repeated_nested_enum:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnum
	0,   // 17: hybrid.goproto.proto.testeditions.TestAllTypes.repeated_foreign_enum:type_name -> hybrid.goproto.proto.testeditions.ForeignEnum
	36,  // 18: hybrid.goproto.proto.testeditions.TestAllTypes.repeated_importenum:type_name -> hybrid.goproto.proto.testeditions.ImportEnum
	15,  // 19: hybrid.goproto.proto.testeditions.TestAllTypes.map_int32_int32:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32Int32Entry
	16,  // 20: hybrid.goproto.proto.testeditions.TestAllTypes.map_int64_int64:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapInt64Int64Entry
	17,  // 21: hybrid.goproto.proto.testeditions.TestAllTypes.map_uint32_uint32:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapUint32Uint32Entry
	18,  // 22: hybrid.goproto.proto.testeditions.TestAllTypes.map_uint64_uint64:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapUint64Uint64Entry
	19,  // 23: hybrid.goproto.proto.testeditions.TestAllTypes.map_sint32_sint32:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapSint32Sint32Entry
	20,  // 24: hybrid.goproto.proto.testeditions.TestAllTypes.map_sint64_sint64:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapSint64Sint64Entry
	21,  // 25: hybrid.goproto.proto.testeditions.TestAllTypes.map_fixed32_fixed32:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapFixed32Fixed32Entry
	22,  // 26: hybrid.goproto.proto.testeditions.TestAllTypes.map_fixed64_fixed64:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapFixed64Fixed64Entry
	23,  // 27: hybrid.goproto.proto.testeditions.TestAllTypes.map_sfixed32_sfixed32:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapSfixed32Sfixed32Entry
	24,  // 28: hybrid.goproto.proto.testeditions.TestAllTypes.map_sfixed64_sfixed64:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapSfixed64Sfixed64Entry
	25,  // 29: hybrid.goproto.proto.testeditions.TestAllTypes.map_int32_float:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32FloatEntry
	26,  // 30: hybrid.goproto.proto.testeditions.TestAllTypes.map_int32_double:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapInt32DoubleEntry
	27,  // 31: hybrid.goproto.proto.testeditions.TestAllTypes.map_bool_bool:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapBoolBoolEntry
	28,  // 32: hybrid.goproto.proto.testeditions.TestAllTypes.map_string_string:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapStringStringEntry
	29,  // 33: hybrid.goproto.proto.testeditions.TestAllTypes.map_string_bytes:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapStringBytesEntry
	30,  // 34: hybrid.goproto.proto.testeditions.TestAllTypes.map_string_nested_message:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapStringNestedMessageEntry
	31,  // 35: hybrid.goproto.proto.testeditions.TestAllTypes.map_string_nested_enum:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.MapStringNestedEnumEntry
	1,   // 36: hybrid.goproto.proto.testeditions.TestAllTypes.default_nested_enum:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnum
	0,   // 37: hybrid.goproto.proto.testeditions.TestAllTypes.default_foreign_enum:type_name -> hybrid.goproto.proto.testeditions.ForeignEnum
	12,  // 38: hybrid.goproto.proto.testeditions.TestAllTypes.oneof_nested_message:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage
	1,   // 39: hybrid.goproto.proto.testeditions.TestAllTypes.oneof_enum:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnum
	32,  // 40: hybrid.goproto.proto.testeditions.TestAllTypes.oneofgroup:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.OneofGroup
	2,   // 41: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f1:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 42: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f2:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 43: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f3:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 44: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f4:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 45: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f5:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 46: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f6:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 47: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f7:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 48: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f8:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 49: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f9:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 50: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f10:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 51: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f11:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 52: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f12:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 53: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f13:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 54: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f14:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 55: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f15:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 56: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f16:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 57: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f17:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 58: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f18:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 59: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f19:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 60: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f20:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 61: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f21:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 62: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f22:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 63: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f23:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 64: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f24:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 65: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f25:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 66: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f26:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 67: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f27:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 68: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f28:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 69: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f29:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 70: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f30:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 71: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f31:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 72: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f32:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 73: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f33:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 74: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f34:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 75: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f35:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 76: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f36:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 77: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f37:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 78: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f38:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 79: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f39:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 80: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f40:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 81: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f41:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 82: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f42:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 83: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f43:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 84: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f44:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 85: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f45:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 86: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f46:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 87: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f47:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 88: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f48:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 89: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f49:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 90: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f50:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 91: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f51:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 92: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f52:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 93: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f53:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 94: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f54:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 95: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f55:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 96: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f56:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 97: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f57:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 98: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f58:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 99: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f59:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 100: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f60:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 101: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f61:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 102: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f62:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 103: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f63:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 104: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f64:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 105: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f65:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 106: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f66:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 107: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f67:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 108: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f68:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 109: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f69:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 110: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f70:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 111: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f71:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 112: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f72:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 113: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f73:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 114: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f74:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 115: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f75:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 116: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f76:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 117: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f77:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 118: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f78:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 119: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f79:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 120: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f80:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 121: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f81:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 122: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f82:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 123: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f83:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 124: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f84:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 125: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f85:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 126: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f86:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 127: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f87:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 128: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f88:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 129: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f89:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 130: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f90:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 131: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f91:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 132: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f92:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 133: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f93:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 134: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f94:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 135: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f95:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 136: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f96:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 137: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f97:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 138: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f98:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 139: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f99:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	2,   // 140: hybrid.goproto.proto.testeditions.TestManyMessageFieldsMessage.f100:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	5,   // 141: hybrid.goproto.proto.testeditions.TestRequiredForeign.optional_message:type_name -> hybrid.goproto.proto.testeditions.TestRequired
	5,   // 142: hybrid.goproto.proto.testeditions.TestRequiredForeign.repeated_message:type_name -> hybrid.goproto.proto.testeditions.TestRequired
	33,  // 143: hybrid.goproto.proto.testeditions.TestRequiredForeign.map_message:type_name -> hybrid.goproto.proto.testeditions.TestRequiredForeign.MapMessageEntry
	5,   // 144: hybrid.goproto.proto.testeditions.TestRequiredForeign.oneof_message:type_name -> hybrid.goproto.proto.testeditions.TestRequired
	34,  // 145: hybrid.goproto.proto.testeditions.TestRequiredGroupFields.optionalgroup:type_name -> hybrid.goproto.proto.testeditions.TestRequiredGroupFields.OptionalGroup
	35,  // 146: hybrid.goproto.proto.testeditions.TestRequiredGroupFields.repeatedgroup:type_name -> hybrid.goproto.proto.testeditions.TestRequiredGroupFields.RepeatedGroup
	5,   // 147: hybrid.goproto.proto.testeditions.TestRequiredLazy.optional_lazy_message:type_name -> hybrid.goproto.proto.testeditions.TestRequired
	0,   // 148: hybrid.goproto.proto.testeditions.TestPackedTypes.packed_enum:type_name -> hybrid.goproto.proto.testeditions.ForeignEnum
	38,  // 149: hybrid.goproto.proto.testeditions.RemoteDefault.default:type_name -> hybrid.goproto.proto.enums.Enum
	38,  // 150: hybrid.goproto.proto.testeditions.RemoteDefault.zero:type_name -> hybrid.goproto.proto.enums.Enum
	38,  // 151: hybrid.goproto.proto.testeditions.RemoteDefault.one:type_name -> hybrid.goproto.proto.enums.Enum
	38,  // 152: hybrid.goproto.proto.testeditions.RemoteDefault.elevent:type_name -> hybrid.goproto.proto.enums.Enum
	38,  // 153: hybrid.goproto.proto.testeditions.RemoteDefault.seventeen:type_name -> hybrid.goproto.proto.enums.Enum
	38,  // 154: hybrid.goproto.proto.testeditions.RemoteDefault.thirtyseven:type_name -> hybrid.goproto.proto.enums.Enum
	38,  // 155: hybrid.goproto.proto.testeditions.RemoteDefault.sixtyseven:type_name -> hybrid.goproto.proto.enums.Enum
	38,  // 156: hybrid.goproto.proto.testeditions.RemoteDefault.negative:type_name -> hybrid.goproto.proto.enums.Enum
	2,   // 157: hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage.corecursive:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes
	12,  // 158: hybrid.goproto.proto.testeditions.TestAllTypes.OptionalGroup.optional_nested_message:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage
	12,  // 159: hybrid.goproto.proto.testeditions.TestAllTypes.RepeatedGroup.optional_nested_message:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage
	12,  // 160: hybrid.goproto.proto.testeditions.TestAllTypes.MapStringNestedMessageEntry.value:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedMessage
	1,   // 161: hybrid.goproto.proto.testeditions.TestAllTypes.MapStringNestedEnumEntry.value:type_name -> hybrid.goproto.proto.testeditions.TestAllTypes.NestedEnum
	5,   // 162: hybrid.goproto.proto.testeditions.TestRequiredForeign.MapMessageEntry.value:type_name -> hybrid.goproto.proto.testeditions.TestRequired
	10,  // 163: hybrid.goproto.proto.testeditions.packed_int32:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 164: hybrid.goproto.proto.testeditions.packed_int64:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 165: hybrid.goproto.proto.testeditions.packed_uint32:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 166: hybrid.goproto.proto.testeditions.packed_uint64:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 167: hybrid.goproto.proto.testeditions.packed_sint32:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 168: hybrid.goproto.proto.testeditions.packed_sint64:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 169: hybrid.goproto.proto.testeditions.packed_fixed32:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 170: hybrid.goproto.proto.testeditions.packed_fixed64:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 171: hybrid.goproto.proto.testeditions.packed_sfixed32:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 172: hybrid.goproto.proto.testeditions.packed_sfixed64:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 173: hybrid.goproto.proto.testeditions.packed_float:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 174: hybrid.goproto.proto.testeditions.packed_double:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 175: hybrid.goproto.proto.testeditions.packed_bool:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	10,  // 176: hybrid.goproto.proto.testeditions.packed_enum:extendee -> hybrid.goproto.proto.testeditions.TestPackedExtensions
	0,   // 177: hybrid.goproto.proto.testeditions.packed_enum:type_name -> hybrid.goproto.proto.testeditions.ForeignEnum
	178, // [178:178] is the sub-list for method output_type
	178, // [178:178] is the sub-list for method input_type
	177, // [177:178] is the sub-list for extension type_name
	163, // [163:177] is the sub-list for extension extendee
	0,   // [0:163] is the sub-list for field type_name
}

func init() { file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_init() }
func file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_init() {
	if File_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto != nil {
		return
	}
	file_internal_testprotos_testeditions_testeditions_hybrid_test_import_hybrid_proto_init()
	file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[0].OneofWrappers = []any{
		(*TestAllTypes_OneofUint32)(nil),
		(*TestAllTypes_OneofNestedMessage)(nil),
		(*TestAllTypes_OneofString)(nil),
		(*TestAllTypes_OneofBytes)(nil),
		(*TestAllTypes_OneofBool)(nil),
		(*TestAllTypes_OneofUint64)(nil),
		(*TestAllTypes_OneofFloat)(nil),
		(*TestAllTypes_OneofDouble)(nil),
		(*TestAllTypes_OneofEnum)(nil),
		(*TestAllTypes_Oneofgroup)(nil),
		(*TestAllTypes_OneofOptionalUint32)(nil),
	}
	file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes[4].OneofWrappers = []any{
		(*TestRequiredForeign_OneofMessage)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_rawDesc), len(file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   34,
			NumExtensions: 14,
			NumServices:   0,
		},
		GoTypes:           file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_goTypes,
		DependencyIndexes: file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_depIdxs,
		EnumInfos:         file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_enumTypes,
		MessageInfos:      file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_msgTypes,
		ExtensionInfos:    file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_extTypes,
	}.Build()
	File_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto = out.File
	file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_goTypes = nil
	file_internal_testprotos_testeditions_testeditions_hybrid_test_hybrid_proto_depIdxs = nil
}