// Copyright 2018 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/test3/test3_hybrid/test.hybrid.proto

//go:build !protoopaque

package test3_hybrid

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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_test3_test3_hybrid_test_hybrid_proto_enumTypes[0].Descriptor()
}

func (ForeignEnum) Type() protoreflect.EnumType {
	return &file_internal_testprotos_test3_test3_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_test3_test3_hybrid_test_hybrid_proto_enumTypes[1].Descriptor()
}

func (TestAllTypes_NestedEnum) Type() protoreflect.EnumType {
	return &file_internal_testprotos_test3_test3_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,81,opt,name=singular_int32,json=singularInt32,proto3" json:"singular_int32,omitempty"`
	SingularInt64          int64                                  `protobuf:"varint,82,opt,name=singular_int64,json=singularInt64,proto3" json:"singular_int64,omitempty"`
	SingularUint32         uint32                                 `protobuf:"varint,83,opt,name=singular_uint32,json=singularUint32,proto3" json:"singular_uint32,omitempty"`
	SingularUint64         uint64                                 `protobuf:"varint,84,opt,name=singular_uint64,json=singularUint64,proto3" json:"singular_uint64,omitempty"`
	SingularSint32         int32                                  `protobuf:"zigzag32,85,opt,name=singular_sint32,json=singularSint32,proto3" json:"singular_sint32,omitempty"`
	SingularSint64         int64                                  `protobuf:"zigzag64,86,opt,name=singular_sint64,json=singularSint64,proto3" json:"singular_sint64,omitempty"`
	SingularFixed32        uint32                                 `protobuf:"fixed32,87,opt,name=singular_fixed32,json=singularFixed32,proto3" json:"singular_fixed32,omitempty"`
	SingularFixed64        uint64                                 `protobuf:"fixed64,88,opt,name=singular_fixed64,json=singularFixed64,proto3" json:"singular_fixed64,omitempty"`
	SingularSfixed32       int32                                  `protobuf:"fixed32,89,opt,name=singular_sfixed32,json=singularSfixed32,proto3" json:"singular_sfixed32,omitempty"`
	SingularSfixed64       int64                                  `protobuf:"fixed64,90,opt,name=singular_sfixed64,json=singularSfixed64,proto3" json:"singular_sfixed64,omitempty"`
	SingularFloat          float32                                `protobuf:"fixed32,91,opt,name=singular_float,json=singularFloat,proto3" json:"singular_float,omitempty"`
	SingularDouble         float64                                `protobuf:"fixed64,92,opt,name=singular_double,json=singularDouble,proto3" json:"singular_double,omitempty"`
	SingularBool           bool                                   `protobuf:"varint,93,opt,name=singular_bool,json=singularBool,proto3" json:"singular_bool,omitempty"`
	SingularString         string                                 `protobuf:"bytes,94,opt,name=singular_string,json=singularString,proto3" json:"singular_string,omitempty"`
	SingularBytes          []byte                                 `protobuf:"bytes,95,opt,name=singular_bytes,json=singularBytes,proto3" json:"singular_bytes,omitempty"`
	SingularNestedMessage  *TestAllTypes_NestedMessage            `protobuf:"bytes,98,opt,name=singular_nested_message,json=singularNestedMessage,proto3" json:"singular_nested_message,omitempty"`
	SingularForeignMessage *ForeignMessage                        `protobuf:"bytes,99,opt,name=singular_foreign_message,json=singularForeignMessage,proto3" json:"singular_foreign_message,omitempty"`
	SingularImportMessage  *ImportMessage                         `protobuf:"bytes,100,opt,name=singular_import_message,json=singularImportMessage,proto3" json:"singular_import_message,omitempty"`
	SingularNestedEnum     TestAllTypes_NestedEnum                `protobuf:"varint,101,opt,name=singular_nested_enum,json=singularNestedEnum,proto3,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum" json:"singular_nested_enum,omitempty"`
	SingularForeignEnum    ForeignEnum                            `protobuf:"varint,102,opt,name=singular_foreign_enum,json=singularForeignEnum,proto3,enum=hybrid.goproto.proto.test3.ForeignEnum" json:"singular_foreign_enum,omitempty"`
	SingularImportEnum     ImportEnum                             `protobuf:"varint,103,opt,name=singular_import_enum,json=singularImportEnum,proto3,enum=hybrid.goproto.proto.test3.ImportEnum" json:"singular_import_enum,omitempty"`
	OptionalInt32          *int32                                 `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32,proto3,oneof" json:"optional_int32,omitempty"`
	OptionalInt64          *int64                                 `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64,proto3,oneof" json:"optional_int64,omitempty"`
	OptionalUint32         *uint32                                `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32,proto3,oneof" json:"optional_uint32,omitempty"`
	OptionalUint64         *uint64                                `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64,proto3,oneof" json:"optional_uint64,omitempty"`
	OptionalSint32         *int32                                 `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32,proto3,oneof" json:"optional_sint32,omitempty"`
	OptionalSint64         *int64                                 `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64,proto3,oneof" json:"optional_sint64,omitempty"`
	OptionalFixed32        *uint32                                `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32,proto3,oneof" json:"optional_fixed32,omitempty"`
	OptionalFixed64        *uint64                                `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64,proto3,oneof" json:"optional_fixed64,omitempty"`
	OptionalSfixed32       *int32                                 `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32,proto3,oneof" json:"optional_sfixed32,omitempty"`
	OptionalSfixed64       *int64                                 `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64,proto3,oneof" json:"optional_sfixed64,omitempty"`
	OptionalFloat          *float32                               `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat,proto3,oneof" json:"optional_float,omitempty"`
	OptionalDouble         *float64                               `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble,proto3,oneof" json:"optional_double,omitempty"`
	OptionalBool           *bool                                  `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool,proto3,oneof" json:"optional_bool,omitempty"`
	OptionalString         *string                                `protobuf:"bytes,14,opt,name=optional_string,json=optionalString,proto3,oneof" json:"optional_string,omitempty"`
	OptionalBytes          []byte                                 `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes,proto3,oneof" json:"optional_bytes,omitempty"`
	OptionalNestedMessage  *TestAllTypes_NestedMessage            `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage,proto3,oneof" json:"optional_nested_message,omitempty"`
	OptionalForeignMessage *ForeignMessage                        `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage,proto3,oneof" json:"optional_foreign_message,omitempty"`
	OptionalImportMessage  *ImportMessage                         `protobuf:"bytes,20,opt,name=optional_import_message,json=optionalImportMessage,proto3,oneof" json:"optional_import_message,omitempty"`
	OptionalNestedEnum     *TestAllTypes_NestedEnum               `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,proto3,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum,oneof" json:"optional_nested_enum,omitempty"`
	OptionalForeignEnum    *ForeignEnum                           `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,proto3,enum=hybrid.goproto.proto.test3.ForeignEnum,oneof" json:"optional_foreign_enum,omitempty"`
	OptionalImportEnum     *ImportEnum                            `protobuf:"varint,23,opt,name=optional_import_enum,json=optionalImportEnum,proto3,enum=hybrid.goproto.proto.test3.ImportEnum,oneof" json:"optional_import_enum,omitempty"`
	RepeatedInt32          []int32                                `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32,proto3" json:"repeated_int32,omitempty"`
	RepeatedInt64          []int64                                `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64,proto3" json:"repeated_int64,omitempty"`
	RepeatedUint32         []uint32                               `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32,proto3" json:"repeated_uint32,omitempty"`
	RepeatedUint64         []uint64                               `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64,proto3" json:"repeated_uint64,omitempty"`
	RepeatedSint32         []int32                                `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32,proto3" json:"repeated_sint32,omitempty"`
	RepeatedSint64         []int64                                `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64,proto3" json:"repeated_sint64,omitempty"`
	RepeatedFixed32        []uint32                               `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32,proto3" json:"repeated_fixed32,omitempty"`
	RepeatedFixed64        []uint64                               `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64,proto3" json:"repeated_fixed64,omitempty"`
	RepeatedSfixed32       []int32                                `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32,proto3" json:"repeated_sfixed32,omitempty"`
	RepeatedSfixed64       []int64                                `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64,proto3" json:"repeated_sfixed64,omitempty"`
	RepeatedFloat          []float32                              `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat,proto3" json:"repeated_float,omitempty"`
	RepeatedDouble         []float64                              `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble,proto3" json:"repeated_double,omitempty"`
	RepeatedBool           []bool                                 `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool,proto3" json:"repeated_bool,omitempty"`
	RepeatedString         []string                               `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString,proto3" json:"repeated_string,omitempty"`
	RepeatedBytes          [][]byte                               `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes,proto3" json:"repeated_bytes,omitempty"`
	RepeatedNestedMessage  []*TestAllTypes_NestedMessage          `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage,proto3" json:"repeated_nested_message,omitempty"`
	RepeatedForeignMessage []*ForeignMessage                      `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage,proto3" json:"repeated_foreign_message,omitempty"`
	RepeatedImportmessage  []*ImportMessage                       `protobuf:"bytes,50,rep,name=repeated_importmessage,json=repeatedImportmessage,proto3" json:"repeated_importmessage,omitempty"`
	RepeatedNestedEnum     []TestAllTypes_NestedEnum              `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,proto3,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum" json:"repeated_nested_enum,omitempty"`
	RepeatedForeignEnum    []ForeignEnum                          `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,proto3,enum=hybrid.goproto.proto.test3.ForeignEnum" json:"repeated_foreign_enum,omitempty"`
	RepeatedImportenum     []ImportEnum                           `protobuf:"varint,53,rep,packed,name=repeated_importenum,json=repeatedImportenum,proto3,enum=hybrid.goproto.proto.test3.ImportEnum" json:"repeated_importenum,omitempty"`
	MapInt32Int32          map[int32]int32                        `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" 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,proto3" json:"map_string_nested_enum,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum"`
	// 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
	OneofField    isTestAllTypes_OneofField `protobuf_oneof:"oneof_field"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestAllTypes) Reset() {
	*x = TestAllTypes{}
	mi := &file_internal_testprotos_test3_test3_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_test3_test3_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) GetSingularNestedMessage() *TestAllTypes_NestedMessage {
	if x != nil {
		return x.SingularNestedMessage
	}
	return nil
}

func (x *TestAllTypes) GetSingularForeignMessage() *ForeignMessage {
	if x != nil {
		return x.SingularForeignMessage
	}
	return nil
}

func (x *TestAllTypes) GetSingularImportMessage() *ImportMessage {
	if x != nil {
		return x.SingularImportMessage
	}
	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) 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) 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) 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) 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) 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) SetSingularNestedMessage(v *TestAllTypes_NestedMessage) {
	x.SingularNestedMessage = v
}

func (x *TestAllTypes) SetSingularForeignMessage(v *ForeignMessage) {
	x.SingularForeignMessage = v
}

func (x *TestAllTypes) SetSingularImportMessage(v *ImportMessage) {
	x.SingularImportMessage = 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) 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) 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) 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) 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) HasSingularNestedMessage() bool {
	if x == nil {
		return false
	}
	return x.SingularNestedMessage != nil
}

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

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

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) 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) 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) ClearSingularNestedMessage() {
	x.SingularNestedMessage = nil
}

func (x *TestAllTypes) ClearSingularForeignMessage() {
	x.SingularForeignMessage = nil
}

func (x *TestAllTypes) ClearSingularImportMessage() {
	x.SingularImportMessage = nil
}

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) 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) 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
	}
}

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

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
	default:
		return TestAllTypes_OneofField_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
	SingularNestedMessage  *TestAllTypes_NestedMessage
	SingularForeignMessage *ForeignMessage
	SingularImportMessage  *ImportMessage
	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
	OptionalNestedMessage  *TestAllTypes_NestedMessage
	OptionalForeignMessage *ForeignMessage
	OptionalImportMessage  *ImportMessage
	OptionalNestedEnum     *TestAllTypes_NestedEnum
	OptionalForeignEnum    *ForeignEnum
	OptionalImportEnum     *ImportEnum
	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
	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
	// Fields of oneof OneofField:
	OneofUint32        *uint32
	OneofNestedMessage *TestAllTypes_NestedMessage
	OneofString        *string
	OneofBytes         []byte
	OneofBool          *bool
	OneofUint64        *uint64
	OneofFloat         *float32
	OneofDouble        *float64
	OneofEnum          *TestAllTypes_NestedEnum
	// -- end of OneofField
}

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.SingularNestedMessage = b.SingularNestedMessage
	x.SingularForeignMessage = b.SingularForeignMessage
	x.SingularImportMessage = b.SingularImportMessage
	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.OptionalNestedMessage = b.OptionalNestedMessage
	x.OptionalForeignMessage = b.OptionalForeignMessage
	x.OptionalImportMessage = b.OptionalImportMessage
	x.OptionalNestedEnum = b.OptionalNestedEnum
	x.OptionalForeignEnum = b.OptionalForeignEnum
	x.OptionalImportEnum = b.OptionalImportEnum
	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.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
	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}
	}
	return m0
}

type case_TestAllTypes_OneofField protoreflect.FieldNumber

func (x case_TestAllTypes_OneofField) String() string {
	md := file_internal_testprotos_test3_test3_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,proto3,oneof"`
}

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

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

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

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

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

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

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

type TestAllTypes_OneofEnum struct {
	OneofEnum TestAllTypes_NestedEnum `protobuf:"varint,119,opt,name=oneof_enum,json=oneofEnum,proto3,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum,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() {}

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

func (x *ForeignMessage) Reset() {
	*x = ForeignMessage{}
	mi := &file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_msgTypes[1]
	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_test3_test3_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 *ForeignMessage) GetC() int32 {
	if x != nil {
		return x.C
	}
	return 0
}

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

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

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

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 TestAllTypes_NestedMessage struct {
	state         protoimpl.MessageState `protogen:"hybrid.v1"`
	A             int32                  `protobuf:"varint,1,opt,name=a,proto3" json:"a,omitempty"`
	Corecursive   *TestAllTypes          `protobuf:"bytes,2,opt,name=corecursive,proto3" json:"corecursive,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *TestAllTypes_NestedMessage) Reset() {
	*x = TestAllTypes_NestedMessage{}
	mi := &file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_msgTypes[2]
	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_test3_test3_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 *TestAllTypes_NestedMessage) GetA() int32 {
	if x != 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) HasCorecursive() bool {
	if x == nil {
		return false
	}
	return x.Corecursive != 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
}

var File_internal_testprotos_test3_test3_hybrid_test_hybrid_proto protoreflect.FileDescriptor

const file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_rawDesc = "" +
	"\n" +
	"8internal/testprotos/test3/test3_hybrid/test.hybrid.proto\x12\x1ahybrid.goproto.proto.test3\x1a?internal/testprotos/test3/test3_hybrid/test_import.hybrid.proto\"\xa9>\n" +
	"\fTestAllTypes\x12%\n" +
	"\x0esingular_int32\x18Q \x01(\x05R\rsingularInt32\x12%\n" +
	"\x0esingular_int64\x18R \x01(\x03R\rsingularInt64\x12'\n" +
	"\x0fsingular_uint32\x18S \x01(\rR\x0esingularUint32\x12'\n" +
	"\x0fsingular_uint64\x18T \x01(\x04R\x0esingularUint64\x12'\n" +
	"\x0fsingular_sint32\x18U \x01(\x11R\x0esingularSint32\x12'\n" +
	"\x0fsingular_sint64\x18V \x01(\x12R\x0esingularSint64\x12)\n" +
	"\x10singular_fixed32\x18W \x01(\aR\x0fsingularFixed32\x12)\n" +
	"\x10singular_fixed64\x18X \x01(\x06R\x0fsingularFixed64\x12+\n" +
	"\x11singular_sfixed32\x18Y \x01(\x0fR\x10singularSfixed32\x12+\n" +
	"\x11singular_sfixed64\x18Z \x01(\x10R\x10singularSfixed64\x12%\n" +
	"\x0esingular_float\x18[ \x01(\x02R\rsingularFloat\x12'\n" +
	"\x0fsingular_double\x18\\ \x01(\x01R\x0esingularDouble\x12#\n" +
	"\rsingular_bool\x18] \x01(\bR\fsingularBool\x12'\n" +
	"\x0fsingular_string\x18^ \x01(\tR\x0esingularString\x12%\n" +
	"\x0esingular_bytes\x18_ \x01(\fR\rsingularBytes\x12n\n" +
	"\x17singular_nested_message\x18b \x01(\v26.hybrid.goproto.proto.test3.TestAllTypes.NestedMessageR\x15singularNestedMessage\x12d\n" +
	"\x18singular_foreign_message\x18c \x01(\v2*.hybrid.goproto.proto.test3.ForeignMessageR\x16singularForeignMessage\x12a\n" +
	"\x17singular_import_message\x18d \x01(\v2).hybrid.goproto.proto.test3.ImportMessageR\x15singularImportMessage\x12e\n" +
	"\x14singular_nested_enum\x18e \x01(\x0e23.hybrid.goproto.proto.test3.TestAllTypes.NestedEnumR\x12singularNestedEnum\x12[\n" +
	"\x15singular_foreign_enum\x18f \x01(\x0e2'.hybrid.goproto.proto.test3.ForeignEnumR\x13singularForeignEnum\x12X\n" +
	"\x14singular_import_enum\x18g \x01(\x0e2&.hybrid.goproto.proto.test3.ImportEnumR\x12singularImportEnum\x12*\n" +
	"\x0eoptional_int32\x18\x01 \x01(\x05H\x01R\roptionalInt32\x88\x01\x01\x12*\n" +
	"\x0eoptional_int64\x18\x02 \x01(\x03H\x02R\roptionalInt64\x88\x01\x01\x12,\n" +
	"\x0foptional_uint32\x18\x03 \x01(\rH\x03R\x0eoptionalUint32\x88\x01\x01\x12,\n" +
	"\x0foptional_uint64\x18\x04 \x01(\x04H\x04R\x0eoptionalUint64\x88\x01\x01\x12,\n" +
	"\x0foptional_sint32\x18\x05 \x01(\x11H\x05R\x0eoptionalSint32\x88\x01\x01\x12,\n" +
	"\x0foptional_sint64\x18\x06 \x01(\x12H\x06R\x0eoptionalSint64\x88\x01\x01\x12.\n" +
	"\x10optional_fixed32\x18\a \x01(\aH\aR\x0foptionalFixed32\x88\x01\x01\x12.\n" +
	"\x10optional_fixed64\x18\b \x01(\x06H\bR\x0foptionalFixed64\x88\x01\x01\x120\n" +
	"\x11optional_sfixed32\x18\t \x01(\x0fH\tR\x10optionalSfixed32\x88\x01\x01\x120\n" +
	"\x11optional_sfixed64\x18\n" +
	" \x01(\x10H\n" +
	"R\x10optionalSfixed64\x88\x01\x01\x12*\n" +
	"\x0eoptional_float\x18\v \x01(\x02H\vR\roptionalFloat\x88\x01\x01\x12,\n" +
	"\x0foptional_double\x18\f \x01(\x01H\fR\x0eoptionalDouble\x88\x01\x01\x12(\n" +
	"\roptional_bool\x18\r \x01(\bH\rR\foptionalBool\x88\x01\x01\x12,\n" +
	"\x0foptional_string\x18\x0e \x01(\tH\x0eR\x0eoptionalString\x88\x01\x01\x12*\n" +
	"\x0eoptional_bytes\x18\x0f \x01(\fH\x0fR\roptionalBytes\x88\x01\x01\x12s\n" +
	"\x17optional_nested_message\x18\x12 \x01(\v26.hybrid.goproto.proto.test3.TestAllTypes.NestedMessageH\x10R\x15optionalNestedMessage\x88\x01\x01\x12i\n" +
	"\x18optional_foreign_message\x18\x13 \x01(\v2*.hybrid.goproto.proto.test3.ForeignMessageH\x11R\x16optionalForeignMessage\x88\x01\x01\x12f\n" +
	"\x17optional_import_message\x18\x14 \x01(\v2).hybrid.goproto.proto.test3.ImportMessageH\x12R\x15optionalImportMessage\x88\x01\x01\x12j\n" +
	"\x14optional_nested_enum\x18\x15 \x01(\x0e23.hybrid.goproto.proto.test3.TestAllTypes.NestedEnumH\x13R\x12optionalNestedEnum\x88\x01\x01\x12`\n" +
	"\x15optional_foreign_enum\x18\x16 \x01(\x0e2'.hybrid.goproto.proto.test3.ForeignEnumH\x14R\x13optionalForeignEnum\x88\x01\x01\x12]\n" +
	"\x14optional_import_enum\x18\x17 \x01(\x0e2&.hybrid.goproto.proto.test3.ImportEnumH\x15R\x12optionalImportEnum\x88\x01\x01\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\x12n\n" +
	"\x17repeated_nested_message\x180 \x03(\v26.hybrid.goproto.proto.test3.TestAllTypes.NestedMessageR\x15repeatedNestedMessage\x12d\n" +
	"\x18repeated_foreign_message\x181 \x03(\v2*.hybrid.goproto.proto.test3.ForeignMessageR\x16repeatedForeignMessage\x12`\n" +
	"\x16repeated_importmessage\x182 \x03(\v2).hybrid.goproto.proto.test3.ImportMessageR\x15repeatedImportmessage\x12e\n" +
	"\x14repeated_nested_enum\x183 \x03(\x0e23.hybrid.goproto.proto.test3.TestAllTypes.NestedEnumR\x12repeatedNestedEnum\x12[\n" +
	"\x15repeated_foreign_enum\x184 \x03(\x0e2'.hybrid.goproto.proto.test3.ForeignEnumR\x13repeatedForeignEnum\x12W\n" +
	"\x13repeated_importenum\x185 \x03(\x0e2&.hybrid.goproto.proto.test3.ImportEnumR\x12repeatedImportenum\x12c\n" +
	"\x0fmap_int32_int32\x188 \x03(\v2;.hybrid.goproto.proto.test3.TestAllTypes.MapInt32Int32EntryR\rmapInt32Int32\x12c\n" +
	"\x0fmap_int64_int64\x189 \x03(\v2;.hybrid.goproto.proto.test3.TestAllTypes.MapInt64Int64EntryR\rmapInt64Int64\x12i\n" +
	"\x11map_uint32_uint32\x18: \x03(\v2=.hybrid.goproto.proto.test3.TestAllTypes.MapUint32Uint32EntryR\x0fmapUint32Uint32\x12i\n" +
	"\x11map_uint64_uint64\x18; \x03(\v2=.hybrid.goproto.proto.test3.TestAllTypes.MapUint64Uint64EntryR\x0fmapUint64Uint64\x12i\n" +
	"\x11map_sint32_sint32\x18< \x03(\v2=.hybrid.goproto.proto.test3.TestAllTypes.MapSint32Sint32EntryR\x0fmapSint32Sint32\x12i\n" +
	"\x11map_sint64_sint64\x18= \x03(\v2=.hybrid.goproto.proto.test3.TestAllTypes.MapSint64Sint64EntryR\x0fmapSint64Sint64\x12o\n" +
	"\x13map_fixed32_fixed32\x18> \x03(\v2?.hybrid.goproto.proto.test3.TestAllTypes.MapFixed32Fixed32EntryR\x11mapFixed32Fixed32\x12o\n" +
	"\x13map_fixed64_fixed64\x18? \x03(\v2?.hybrid.goproto.proto.test3.TestAllTypes.MapFixed64Fixed64EntryR\x11mapFixed64Fixed64\x12u\n" +
	"\x15map_sfixed32_sfixed32\x18@ \x03(\v2A.hybrid.goproto.proto.test3.TestAllTypes.MapSfixed32Sfixed32EntryR\x13mapSfixed32Sfixed32\x12u\n" +
	"\x15map_sfixed64_sfixed64\x18A \x03(\v2A.hybrid.goproto.proto.test3.TestAllTypes.MapSfixed64Sfixed64EntryR\x13mapSfixed64Sfixed64\x12c\n" +
	"\x0fmap_int32_float\x18B \x03(\v2;.hybrid.goproto.proto.test3.TestAllTypes.MapInt32FloatEntryR\rmapInt32Float\x12f\n" +
	"\x10map_int32_double\x18C \x03(\v2<.hybrid.goproto.proto.test3.TestAllTypes.MapInt32DoubleEntryR\x0emapInt32Double\x12]\n" +
	"\rmap_bool_bool\x18D \x03(\v29.hybrid.goproto.proto.test3.TestAllTypes.MapBoolBoolEntryR\vmapBoolBool\x12i\n" +
	"\x11map_string_string\x18E \x03(\v2=.hybrid.goproto.proto.test3.TestAllTypes.MapStringStringEntryR\x0fmapStringString\x12f\n" +
	"\x10map_string_bytes\x18F \x03(\v2<.hybrid.goproto.proto.test3.TestAllTypes.MapStringBytesEntryR\x0emapStringBytes\x12\x7f\n" +
	"\x19map_string_nested_message\x18G \x03(\v2D.hybrid.goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntryR\x16mapStringNestedMessage\x12v\n" +
	"\x16map_string_nested_enum\x18I \x03(\v2A.hybrid.goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntryR\x13mapStringNestedEnum\x12#\n" +
	"\foneof_uint32\x18o \x01(\rH\x00R\voneofUint32\x12j\n" +
	"\x14oneof_nested_message\x18p \x01(\v26.hybrid.goproto.proto.test3.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\x12T\n" +
	"\n" +
	"oneof_enum\x18w \x01(\x0e23.hybrid.goproto.proto.test3.TestAllTypes.NestedEnumH\x00R\toneofEnum\x1ai\n" +
	"\rNestedMessage\x12\f\n" +
	"\x01a\x18\x01 \x01(\x05R\x01a\x12J\n" +
	"\vcorecursive\x18\x02 \x01(\v2(.hybrid.goproto.proto.test3.TestAllTypesR\vcorecursive\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\x81\x01\n" +
	"\x1bMapStringNestedMessageEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12L\n" +
	"\x05value\x18\x02 \x01(\v26.hybrid.goproto.proto.test3.TestAllTypes.NestedMessageR\x05value:\x028\x01\x1a{\n" +
	"\x18MapStringNestedEnumEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12I\n" +
	"\x05value\x18\x02 \x01(\x0e23.hybrid.goproto.proto.test3.TestAllTypes.NestedEnumR\x05value:\x028\x01\"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\x11\n" +
	"\x0f_optional_int32B\x11\n" +
	"\x0f_optional_int64B\x12\n" +
	"\x10_optional_uint32B\x12\n" +
	"\x10_optional_uint64B\x12\n" +
	"\x10_optional_sint32B\x12\n" +
	"\x10_optional_sint64B\x13\n" +
	"\x11_optional_fixed32B\x13\n" +
	"\x11_optional_fixed64B\x14\n" +
	"\x12_optional_sfixed32B\x14\n" +
	"\x12_optional_sfixed64B\x11\n" +
	"\x0f_optional_floatB\x12\n" +
	"\x10_optional_doubleB\x10\n" +
	"\x0e_optional_boolB\x12\n" +
	"\x10_optional_stringB\x11\n" +
	"\x0f_optional_bytesB\x1a\n" +
	"\x18_optional_nested_messageB\x1b\n" +
	"\x19_optional_foreign_messageB\x1a\n" +
	"\x18_optional_import_messageB\x17\n" +
	"\x15_optional_nested_enumB\x18\n" +
	"\x16_optional_foreign_enumB\x17\n" +
	"\x15_optional_import_enum\",\n" +
	"\x0eForeignMessage\x12\f\n" +
	"\x01c\x18\x01 \x01(\x05R\x01c\x12\f\n" +
	"\x01d\x18\x02 \x01(\x05R\x01d*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\x06BCZAgoogle.golang.org/protobuf/internal/testprotos/test3/test3_hybridb\x06proto3"

var file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_msgTypes = make([]protoimpl.MessageInfo, 20)
var file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_goTypes = []any{
	(ForeignEnum)(0),                   // 0: hybrid.goproto.proto.test3.ForeignEnum
	(TestAllTypes_NestedEnum)(0),       // 1: hybrid.goproto.proto.test3.TestAllTypes.NestedEnum
	(*TestAllTypes)(nil),               // 2: hybrid.goproto.proto.test3.TestAllTypes
	(*ForeignMessage)(nil),             // 3: hybrid.goproto.proto.test3.ForeignMessage
	(*TestAllTypes_NestedMessage)(nil), // 4: hybrid.goproto.proto.test3.TestAllTypes.NestedMessage
	nil,                                // 5: hybrid.goproto.proto.test3.TestAllTypes.MapInt32Int32Entry
	nil,                                // 6: hybrid.goproto.proto.test3.TestAllTypes.MapInt64Int64Entry
	nil,                                // 7: hybrid.goproto.proto.test3.TestAllTypes.MapUint32Uint32Entry
	nil,                                // 8: hybrid.goproto.proto.test3.TestAllTypes.MapUint64Uint64Entry
	nil,                                // 9: hybrid.goproto.proto.test3.TestAllTypes.MapSint32Sint32Entry
	nil,                                // 10: hybrid.goproto.proto.test3.TestAllTypes.MapSint64Sint64Entry
	nil,                                // 11: hybrid.goproto.proto.test3.TestAllTypes.MapFixed32Fixed32Entry
	nil,                                // 12: hybrid.goproto.proto.test3.TestAllTypes.MapFixed64Fixed64Entry
	nil,                                // 13: hybrid.goproto.proto.test3.TestAllTypes.MapSfixed32Sfixed32Entry
	nil,                                // 14: hybrid.goproto.proto.test3.TestAllTypes.MapSfixed64Sfixed64Entry
	nil,                                // 15: hybrid.goproto.proto.test3.TestAllTypes.MapInt32FloatEntry
	nil,                                // 16: hybrid.goproto.proto.test3.TestAllTypes.MapInt32DoubleEntry
	nil,                                // 17: hybrid.goproto.proto.test3.TestAllTypes.MapBoolBoolEntry
	nil,                                // 18: hybrid.goproto.proto.test3.TestAllTypes.MapStringStringEntry
	nil,                                // 19: hybrid.goproto.proto.test3.TestAllTypes.MapStringBytesEntry
	nil,                                // 20: hybrid.goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry
	nil,                                // 21: hybrid.goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry
	(*ImportMessage)(nil),              // 22: hybrid.goproto.proto.test3.ImportMessage
	(ImportEnum)(0),                    // 23: hybrid.goproto.proto.test3.ImportEnum
}
var file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_depIdxs = []int32{
	4,  // 0: hybrid.goproto.proto.test3.TestAllTypes.singular_nested_message:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedMessage
	3,  // 1: hybrid.goproto.proto.test3.TestAllTypes.singular_foreign_message:type_name -> hybrid.goproto.proto.test3.ForeignMessage
	22, // 2: hybrid.goproto.proto.test3.TestAllTypes.singular_import_message:type_name -> hybrid.goproto.proto.test3.ImportMessage
	1,  // 3: hybrid.goproto.proto.test3.TestAllTypes.singular_nested_enum:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedEnum
	0,  // 4: hybrid.goproto.proto.test3.TestAllTypes.singular_foreign_enum:type_name -> hybrid.goproto.proto.test3.ForeignEnum
	23, // 5: hybrid.goproto.proto.test3.TestAllTypes.singular_import_enum:type_name -> hybrid.goproto.proto.test3.ImportEnum
	4,  // 6: hybrid.goproto.proto.test3.TestAllTypes.optional_nested_message:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedMessage
	3,  // 7: hybrid.goproto.proto.test3.TestAllTypes.optional_foreign_message:type_name -> hybrid.goproto.proto.test3.ForeignMessage
	22, // 8: hybrid.goproto.proto.test3.TestAllTypes.optional_import_message:type_name -> hybrid.goproto.proto.test3.ImportMessage
	1,  // 9: hybrid.goproto.proto.test3.TestAllTypes.optional_nested_enum:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedEnum
	0,  // 10: hybrid.goproto.proto.test3.TestAllTypes.optional_foreign_enum:type_name -> hybrid.goproto.proto.test3.ForeignEnum
	23, // 11: hybrid.goproto.proto.test3.TestAllTypes.optional_import_enum:type_name -> hybrid.goproto.proto.test3.ImportEnum
	4,  // 12: hybrid.goproto.proto.test3.TestAllTypes.repeated_nested_message:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedMessage
	3,  // 13: hybrid.goproto.proto.test3.TestAllTypes.repeated_foreign_message:type_name -> hybrid.goproto.proto.test3.ForeignMessage
	22, // 14: hybrid.goproto.proto.test3.TestAllTypes.repeated_importmessage:type_name -> hybrid.goproto.proto.test3.ImportMessage
	1,  // 15: hybrid.goproto.proto.test3.TestAllTypes.repeated_nested_enum:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedEnum
	0,  // 16: hybrid.goproto.proto.test3.TestAllTypes.repeated_foreign_enum:type_name -> hybrid.goproto.proto.test3.ForeignEnum
	23, // 17: hybrid.goproto.proto.test3.TestAllTypes.repeated_importenum:type_name -> hybrid.goproto.proto.test3.ImportEnum
	5,  // 18: hybrid.goproto.proto.test3.TestAllTypes.map_int32_int32:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapInt32Int32Entry
	6,  // 19: hybrid.goproto.proto.test3.TestAllTypes.map_int64_int64:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapInt64Int64Entry
	7,  // 20: hybrid.goproto.proto.test3.TestAllTypes.map_uint32_uint32:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapUint32Uint32Entry
	8,  // 21: hybrid.goproto.proto.test3.TestAllTypes.map_uint64_uint64:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapUint64Uint64Entry
	9,  // 22: hybrid.goproto.proto.test3.TestAllTypes.map_sint32_sint32:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapSint32Sint32Entry
	10, // 23: hybrid.goproto.proto.test3.TestAllTypes.map_sint64_sint64:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapSint64Sint64Entry
	11, // 24: hybrid.goproto.proto.test3.TestAllTypes.map_fixed32_fixed32:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapFixed32Fixed32Entry
	12, // 25: hybrid.goproto.proto.test3.TestAllTypes.map_fixed64_fixed64:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapFixed64Fixed64Entry
	13, // 26: hybrid.goproto.proto.test3.TestAllTypes.map_sfixed32_sfixed32:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapSfixed32Sfixed32Entry
	14, // 27: hybrid.goproto.proto.test3.TestAllTypes.map_sfixed64_sfixed64:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapSfixed64Sfixed64Entry
	15, // 28: hybrid.goproto.proto.test3.TestAllTypes.map_int32_float:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapInt32FloatEntry
	16, // 29: hybrid.goproto.proto.test3.TestAllTypes.map_int32_double:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapInt32DoubleEntry
	17, // 30: hybrid.goproto.proto.test3.TestAllTypes.map_bool_bool:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapBoolBoolEntry
	18, // 31: hybrid.goproto.proto.test3.TestAllTypes.map_string_string:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapStringStringEntry
	19, // 32: hybrid.goproto.proto.test3.TestAllTypes.map_string_bytes:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapStringBytesEntry
	20, // 33: hybrid.goproto.proto.test3.TestAllTypes.map_string_nested_message:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry
	21, // 34: hybrid.goproto.proto.test3.TestAllTypes.map_string_nested_enum:type_name -> hybrid.goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry
	4,  // 35: hybrid.goproto.proto.test3.TestAllTypes.oneof_nested_message:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedMessage
	1,  // 36: hybrid.goproto.proto.test3.TestAllTypes.oneof_enum:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedEnum
	2,  // 37: hybrid.goproto.proto.test3.TestAllTypes.NestedMessage.corecursive:type_name -> hybrid.goproto.proto.test3.TestAllTypes
	4,  // 38: hybrid.goproto.proto.test3.TestAllTypes.MapStringNestedMessageEntry.value:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedMessage
	1,  // 39: hybrid.goproto.proto.test3.TestAllTypes.MapStringNestedEnumEntry.value:type_name -> hybrid.goproto.proto.test3.TestAllTypes.NestedEnum
	40, // [40:40] is the sub-list for method output_type
	40, // [40:40] is the sub-list for method input_type
	40, // [40:40] is the sub-list for extension type_name
	40, // [40:40] is the sub-list for extension extendee
	0,  // [0:40] is the sub-list for field type_name
}

func init() { file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_init() }
func file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_init() {
	if File_internal_testprotos_test3_test3_hybrid_test_hybrid_proto != nil {
		return
	}
	file_internal_testprotos_test3_test3_hybrid_test_import_hybrid_proto_init()
	file_internal_testprotos_test3_test3_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),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_rawDesc), len(file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   20,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_goTypes,
		DependencyIndexes: file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_depIdxs,
		EnumInfos:         file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_enumTypes,
		MessageInfos:      file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_msgTypes,
	}.Build()
	File_internal_testprotos_test3_test3_hybrid_test_hybrid_proto = out.File
	file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_goTypes = nil
	file_internal_testprotos_test3_test3_hybrid_test_hybrid_proto_depIdxs = nil
}
