// 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:"opaque.v1"`
	xxx_hidden_SingularInt32          int32                                  `protobuf:"varint,81,opt,name=singular_int32,json=singularInt32,proto3"`
	xxx_hidden_SingularInt64          int64                                  `protobuf:"varint,82,opt,name=singular_int64,json=singularInt64,proto3"`
	xxx_hidden_SingularUint32         uint32                                 `protobuf:"varint,83,opt,name=singular_uint32,json=singularUint32,proto3"`
	xxx_hidden_SingularUint64         uint64                                 `protobuf:"varint,84,opt,name=singular_uint64,json=singularUint64,proto3"`
	xxx_hidden_SingularSint32         int32                                  `protobuf:"zigzag32,85,opt,name=singular_sint32,json=singularSint32,proto3"`
	xxx_hidden_SingularSint64         int64                                  `protobuf:"zigzag64,86,opt,name=singular_sint64,json=singularSint64,proto3"`
	xxx_hidden_SingularFixed32        uint32                                 `protobuf:"fixed32,87,opt,name=singular_fixed32,json=singularFixed32,proto3"`
	xxx_hidden_SingularFixed64        uint64                                 `protobuf:"fixed64,88,opt,name=singular_fixed64,json=singularFixed64,proto3"`
	xxx_hidden_SingularSfixed32       int32                                  `protobuf:"fixed32,89,opt,name=singular_sfixed32,json=singularSfixed32,proto3"`
	xxx_hidden_SingularSfixed64       int64                                  `protobuf:"fixed64,90,opt,name=singular_sfixed64,json=singularSfixed64,proto3"`
	xxx_hidden_SingularFloat          float32                                `protobuf:"fixed32,91,opt,name=singular_float,json=singularFloat,proto3"`
	xxx_hidden_SingularDouble         float64                                `protobuf:"fixed64,92,opt,name=singular_double,json=singularDouble,proto3"`
	xxx_hidden_SingularBool           bool                                   `protobuf:"varint,93,opt,name=singular_bool,json=singularBool,proto3"`
	xxx_hidden_SingularString         string                                 `protobuf:"bytes,94,opt,name=singular_string,json=singularString,proto3"`
	xxx_hidden_SingularBytes          []byte                                 `protobuf:"bytes,95,opt,name=singular_bytes,json=singularBytes,proto3"`
	xxx_hidden_SingularNestedMessage  *TestAllTypes_NestedMessage            `protobuf:"bytes,98,opt,name=singular_nested_message,json=singularNestedMessage,proto3"`
	xxx_hidden_SingularForeignMessage *ForeignMessage                        `protobuf:"bytes,99,opt,name=singular_foreign_message,json=singularForeignMessage,proto3"`
	xxx_hidden_SingularImportMessage  *ImportMessage                         `protobuf:"bytes,100,opt,name=singular_import_message,json=singularImportMessage,proto3"`
	xxx_hidden_SingularNestedEnum     TestAllTypes_NestedEnum                `protobuf:"varint,101,opt,name=singular_nested_enum,json=singularNestedEnum,proto3,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum"`
	xxx_hidden_SingularForeignEnum    ForeignEnum                            `protobuf:"varint,102,opt,name=singular_foreign_enum,json=singularForeignEnum,proto3,enum=hybrid.goproto.proto.test3.ForeignEnum"`
	xxx_hidden_SingularImportEnum     ImportEnum                             `protobuf:"varint,103,opt,name=singular_import_enum,json=singularImportEnum,proto3,enum=hybrid.goproto.proto.test3.ImportEnum"`
	xxx_hidden_OptionalInt32          int32                                  `protobuf:"varint,1,opt,name=optional_int32,json=optionalInt32,proto3,oneof"`
	xxx_hidden_OptionalInt64          int64                                  `protobuf:"varint,2,opt,name=optional_int64,json=optionalInt64,proto3,oneof"`
	xxx_hidden_OptionalUint32         uint32                                 `protobuf:"varint,3,opt,name=optional_uint32,json=optionalUint32,proto3,oneof"`
	xxx_hidden_OptionalUint64         uint64                                 `protobuf:"varint,4,opt,name=optional_uint64,json=optionalUint64,proto3,oneof"`
	xxx_hidden_OptionalSint32         int32                                  `protobuf:"zigzag32,5,opt,name=optional_sint32,json=optionalSint32,proto3,oneof"`
	xxx_hidden_OptionalSint64         int64                                  `protobuf:"zigzag64,6,opt,name=optional_sint64,json=optionalSint64,proto3,oneof"`
	xxx_hidden_OptionalFixed32        uint32                                 `protobuf:"fixed32,7,opt,name=optional_fixed32,json=optionalFixed32,proto3,oneof"`
	xxx_hidden_OptionalFixed64        uint64                                 `protobuf:"fixed64,8,opt,name=optional_fixed64,json=optionalFixed64,proto3,oneof"`
	xxx_hidden_OptionalSfixed32       int32                                  `protobuf:"fixed32,9,opt,name=optional_sfixed32,json=optionalSfixed32,proto3,oneof"`
	xxx_hidden_OptionalSfixed64       int64                                  `protobuf:"fixed64,10,opt,name=optional_sfixed64,json=optionalSfixed64,proto3,oneof"`
	xxx_hidden_OptionalFloat          float32                                `protobuf:"fixed32,11,opt,name=optional_float,json=optionalFloat,proto3,oneof"`
	xxx_hidden_OptionalDouble         float64                                `protobuf:"fixed64,12,opt,name=optional_double,json=optionalDouble,proto3,oneof"`
	xxx_hidden_OptionalBool           bool                                   `protobuf:"varint,13,opt,name=optional_bool,json=optionalBool,proto3,oneof"`
	xxx_hidden_OptionalString         *string                                `protobuf:"bytes,14,opt,name=optional_string,json=optionalString,proto3,oneof"`
	xxx_hidden_OptionalBytes          []byte                                 `protobuf:"bytes,15,opt,name=optional_bytes,json=optionalBytes,proto3,oneof"`
	xxx_hidden_OptionalNestedMessage  *TestAllTypes_NestedMessage            `protobuf:"bytes,18,opt,name=optional_nested_message,json=optionalNestedMessage,proto3,oneof"`
	xxx_hidden_OptionalForeignMessage *ForeignMessage                        `protobuf:"bytes,19,opt,name=optional_foreign_message,json=optionalForeignMessage,proto3,oneof"`
	xxx_hidden_OptionalImportMessage  *ImportMessage                         `protobuf:"bytes,20,opt,name=optional_import_message,json=optionalImportMessage,proto3,oneof"`
	xxx_hidden_OptionalNestedEnum     TestAllTypes_NestedEnum                `protobuf:"varint,21,opt,name=optional_nested_enum,json=optionalNestedEnum,proto3,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum,oneof"`
	xxx_hidden_OptionalForeignEnum    ForeignEnum                            `protobuf:"varint,22,opt,name=optional_foreign_enum,json=optionalForeignEnum,proto3,enum=hybrid.goproto.proto.test3.ForeignEnum,oneof"`
	xxx_hidden_OptionalImportEnum     ImportEnum                             `protobuf:"varint,23,opt,name=optional_import_enum,json=optionalImportEnum,proto3,enum=hybrid.goproto.proto.test3.ImportEnum,oneof"`
	xxx_hidden_RepeatedInt32          []int32                                `protobuf:"varint,31,rep,packed,name=repeated_int32,json=repeatedInt32,proto3"`
	xxx_hidden_RepeatedInt64          []int64                                `protobuf:"varint,32,rep,packed,name=repeated_int64,json=repeatedInt64,proto3"`
	xxx_hidden_RepeatedUint32         []uint32                               `protobuf:"varint,33,rep,packed,name=repeated_uint32,json=repeatedUint32,proto3"`
	xxx_hidden_RepeatedUint64         []uint64                               `protobuf:"varint,34,rep,packed,name=repeated_uint64,json=repeatedUint64,proto3"`
	xxx_hidden_RepeatedSint32         []int32                                `protobuf:"zigzag32,35,rep,packed,name=repeated_sint32,json=repeatedSint32,proto3"`
	xxx_hidden_RepeatedSint64         []int64                                `protobuf:"zigzag64,36,rep,packed,name=repeated_sint64,json=repeatedSint64,proto3"`
	xxx_hidden_RepeatedFixed32        []uint32                               `protobuf:"fixed32,37,rep,packed,name=repeated_fixed32,json=repeatedFixed32,proto3"`
	xxx_hidden_RepeatedFixed64        []uint64                               `protobuf:"fixed64,38,rep,packed,name=repeated_fixed64,json=repeatedFixed64,proto3"`
	xxx_hidden_RepeatedSfixed32       []int32                                `protobuf:"fixed32,39,rep,packed,name=repeated_sfixed32,json=repeatedSfixed32,proto3"`
	xxx_hidden_RepeatedSfixed64       []int64                                `protobuf:"fixed64,40,rep,packed,name=repeated_sfixed64,json=repeatedSfixed64,proto3"`
	xxx_hidden_RepeatedFloat          []float32                              `protobuf:"fixed32,41,rep,packed,name=repeated_float,json=repeatedFloat,proto3"`
	xxx_hidden_RepeatedDouble         []float64                              `protobuf:"fixed64,42,rep,packed,name=repeated_double,json=repeatedDouble,proto3"`
	xxx_hidden_RepeatedBool           []bool                                 `protobuf:"varint,43,rep,packed,name=repeated_bool,json=repeatedBool,proto3"`
	xxx_hidden_RepeatedString         []string                               `protobuf:"bytes,44,rep,name=repeated_string,json=repeatedString,proto3"`
	xxx_hidden_RepeatedBytes          [][]byte                               `protobuf:"bytes,45,rep,name=repeated_bytes,json=repeatedBytes,proto3"`
	xxx_hidden_RepeatedNestedMessage  *[]*TestAllTypes_NestedMessage         `protobuf:"bytes,48,rep,name=repeated_nested_message,json=repeatedNestedMessage,proto3"`
	xxx_hidden_RepeatedForeignMessage *[]*ForeignMessage                     `protobuf:"bytes,49,rep,name=repeated_foreign_message,json=repeatedForeignMessage,proto3"`
	xxx_hidden_RepeatedImportmessage  *[]*ImportMessage                      `protobuf:"bytes,50,rep,name=repeated_importmessage,json=repeatedImportmessage,proto3"`
	xxx_hidden_RepeatedNestedEnum     []TestAllTypes_NestedEnum              `protobuf:"varint,51,rep,packed,name=repeated_nested_enum,json=repeatedNestedEnum,proto3,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum"`
	xxx_hidden_RepeatedForeignEnum    []ForeignEnum                          `protobuf:"varint,52,rep,packed,name=repeated_foreign_enum,json=repeatedForeignEnum,proto3,enum=hybrid.goproto.proto.test3.ForeignEnum"`
	xxx_hidden_RepeatedImportenum     []ImportEnum                           `protobuf:"varint,53,rep,packed,name=repeated_importenum,json=repeatedImportenum,proto3,enum=hybrid.goproto.proto.test3.ImportEnum"`
	xxx_hidden_MapInt32Int32          map[int32]int32                        `protobuf:"bytes,56,rep,name=map_int32_int32,json=mapInt32Int32,proto3" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	xxx_hidden_MapInt64Int64          map[int64]int64                        `protobuf:"bytes,57,rep,name=map_int64_int64,json=mapInt64Int64,proto3" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	xxx_hidden_MapUint32Uint32        map[uint32]uint32                      `protobuf:"bytes,58,rep,name=map_uint32_uint32,json=mapUint32Uint32,proto3" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	xxx_hidden_MapUint64Uint64        map[uint64]uint64                      `protobuf:"bytes,59,rep,name=map_uint64_uint64,json=mapUint64Uint64,proto3" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	xxx_hidden_MapSint32Sint32        map[int32]int32                        `protobuf:"bytes,60,rep,name=map_sint32_sint32,json=mapSint32Sint32,proto3" protobuf_key:"zigzag32,1,opt,name=key" protobuf_val:"zigzag32,2,opt,name=value"`
	xxx_hidden_MapSint64Sint64        map[int64]int64                        `protobuf:"bytes,61,rep,name=map_sint64_sint64,json=mapSint64Sint64,proto3" protobuf_key:"zigzag64,1,opt,name=key" protobuf_val:"zigzag64,2,opt,name=value"`
	xxx_hidden_MapFixed32Fixed32      map[uint32]uint32                      `protobuf:"bytes,62,rep,name=map_fixed32_fixed32,json=mapFixed32Fixed32,proto3" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	xxx_hidden_MapFixed64Fixed64      map[uint64]uint64                      `protobuf:"bytes,63,rep,name=map_fixed64_fixed64,json=mapFixed64Fixed64,proto3" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	xxx_hidden_MapSfixed32Sfixed32    map[int32]int32                        `protobuf:"bytes,64,rep,name=map_sfixed32_sfixed32,json=mapSfixed32Sfixed32,proto3" protobuf_key:"fixed32,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	xxx_hidden_MapSfixed64Sfixed64    map[int64]int64                        `protobuf:"bytes,65,rep,name=map_sfixed64_sfixed64,json=mapSfixed64Sfixed64,proto3" protobuf_key:"fixed64,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	xxx_hidden_MapInt32Float          map[int32]float32                      `protobuf:"bytes,66,rep,name=map_int32_float,json=mapInt32Float,proto3" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed32,2,opt,name=value"`
	xxx_hidden_MapInt32Double         map[int32]float64                      `protobuf:"bytes,67,rep,name=map_int32_double,json=mapInt32Double,proto3" protobuf_key:"varint,1,opt,name=key" protobuf_val:"fixed64,2,opt,name=value"`
	xxx_hidden_MapBoolBool            map[bool]bool                          `protobuf:"bytes,68,rep,name=map_bool_bool,json=mapBoolBool,proto3" protobuf_key:"varint,1,opt,name=key" protobuf_val:"varint,2,opt,name=value"`
	xxx_hidden_MapStringString        map[string]string                      `protobuf:"bytes,69,rep,name=map_string_string,json=mapStringString,proto3" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	xxx_hidden_MapStringBytes         map[string][]byte                      `protobuf:"bytes,70,rep,name=map_string_bytes,json=mapStringBytes,proto3" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	xxx_hidden_MapStringNestedMessage map[string]*TestAllTypes_NestedMessage `protobuf:"bytes,71,rep,name=map_string_nested_message,json=mapStringNestedMessage,proto3" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	xxx_hidden_MapStringNestedEnum    map[string]TestAllTypes_NestedEnum     `protobuf:"bytes,73,rep,name=map_string_nested_enum,json=mapStringNestedEnum,proto3" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"varint,2,opt,name=value,enum=hybrid.goproto.proto.test3.TestAllTypes_NestedEnum"`
	xxx_hidden_OneofField             isTestAllTypes_OneofField              `protobuf_oneof:"oneof_field"`
	XXX_raceDetectHookData            protoimpl.RaceDetectHookData
	XXX_presence                      [3]uint32
	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.xxx_hidden_SingularInt32
	}
	return 0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (x *TestAllTypes) GetSingularNestedMessage() *TestAllTypes_NestedMessage {
	if x != nil {
		return x.xxx_hidden_SingularNestedMessage
	}
	return nil
}

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

func (x *TestAllTypes) GetSingularImportMessage() *ImportMessage {
	if x != nil {
		return x.xxx_hidden_SingularImportMessage
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (x *TestAllTypes) GetOptionalNestedEnum() TestAllTypes_NestedEnum {
	if x != nil {
		if protoimpl.X.Present(&(x.XXX_presence[1]), 39) {
			return x.xxx_hidden_OptionalNestedEnum
		}
	}
	return TestAllTypes_FOO
}

func (x *TestAllTypes) GetOptionalForeignEnum() ForeignEnum {
	if x != nil {
		if protoimpl.X.Present(&(x.XXX_presence[1]), 40) {
			return x.xxx_hidden_OptionalForeignEnum
		}
	}
	return ForeignEnum_FOREIGN_ZERO
}

func (x *TestAllTypes) GetOptionalImportEnum() ImportEnum {
	if x != nil {
		if protoimpl.X.Present(&(x.XXX_presence[1]), 41) {
			return x.xxx_hidden_OptionalImportEnum
		}
	}
	return ImportEnum_IMPORT_ZERO
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (x *TestAllTypes) SetSingularNestedMessage(v *TestAllTypes_NestedMessage) {
	x.xxx_hidden_SingularNestedMessage = v
}

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

func (x *TestAllTypes) SetSingularImportMessage(v *ImportMessage) {
	x.xxx_hidden_SingularImportMessage = v
}

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

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

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

func (x *TestAllTypes) SetOptionalInt32(v int32) {
	x.xxx_hidden_OptionalInt32 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 21, 81)
}

func (x *TestAllTypes) SetOptionalInt64(v int64) {
	x.xxx_hidden_OptionalInt64 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 22, 81)
}

func (x *TestAllTypes) SetOptionalUint32(v uint32) {
	x.xxx_hidden_OptionalUint32 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 23, 81)
}

func (x *TestAllTypes) SetOptionalUint64(v uint64) {
	x.xxx_hidden_OptionalUint64 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 24, 81)
}

func (x *TestAllTypes) SetOptionalSint32(v int32) {
	x.xxx_hidden_OptionalSint32 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 25, 81)
}

func (x *TestAllTypes) SetOptionalSint64(v int64) {
	x.xxx_hidden_OptionalSint64 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 26, 81)
}

func (x *TestAllTypes) SetOptionalFixed32(v uint32) {
	x.xxx_hidden_OptionalFixed32 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 27, 81)
}

func (x *TestAllTypes) SetOptionalFixed64(v uint64) {
	x.xxx_hidden_OptionalFixed64 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 28, 81)
}

func (x *TestAllTypes) SetOptionalSfixed32(v int32) {
	x.xxx_hidden_OptionalSfixed32 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 29, 81)
}

func (x *TestAllTypes) SetOptionalSfixed64(v int64) {
	x.xxx_hidden_OptionalSfixed64 = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 30, 81)
}

func (x *TestAllTypes) SetOptionalFloat(v float32) {
	x.xxx_hidden_OptionalFloat = v
	protoimpl.X.SetPresent(&(x.XXX_presence[0]), 31, 81)
}

func (x *TestAllTypes) SetOptionalDouble(v float64) {
	x.xxx_hidden_OptionalDouble = v
	protoimpl.X.SetPresent(&(x.XXX_presence[1]), 32, 81)
}

func (x *TestAllTypes) SetOptionalBool(v bool) {
	x.xxx_hidden_OptionalBool = v
	protoimpl.X.SetPresent(&(x.XXX_presence[1]), 33, 81)
}

func (x *TestAllTypes) SetOptionalString(v string) {
	x.xxx_hidden_OptionalString = &v
	protoimpl.X.SetPresent(&(x.XXX_presence[1]), 34, 81)
}

func (x *TestAllTypes) SetOptionalBytes(v []byte) {
	if v == nil {
		v = []byte{}
	}
	x.xxx_hidden_OptionalBytes = v
	protoimpl.X.SetPresent(&(x.XXX_presence[1]), 35, 81)
}

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

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

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

func (x *TestAllTypes) SetOptionalNestedEnum(v TestAllTypes_NestedEnum) {
	x.xxx_hidden_OptionalNestedEnum = v
	protoimpl.X.SetPresent(&(x.XXX_presence[1]), 39, 81)
}

func (x *TestAllTypes) SetOptionalForeignEnum(v ForeignEnum) {
	x.xxx_hidden_OptionalForeignEnum = v
	protoimpl.X.SetPresent(&(x.XXX_presence[1]), 40, 81)
}

func (x *TestAllTypes) SetOptionalImportEnum(v ImportEnum) {
	x.xxx_hidden_OptionalImportEnum = v
	protoimpl.X.SetPresent(&(x.XXX_presence[1]), 41, 81)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (x *TestAllTypes) SetOneofUint32(v uint32) {
	x.xxx_hidden_OneofField = &testAllTypes_OneofUint32{v}
}

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

func (x *TestAllTypes) SetOneofString(v string) {
	x.xxx_hidden_OneofField = &testAllTypes_OneofString{v}
}

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

func (x *TestAllTypes) SetOneofBool(v bool) {
	x.xxx_hidden_OneofField = &testAllTypes_OneofBool{v}
}

func (x *TestAllTypes) SetOneofUint64(v uint64) {
	x.xxx_hidden_OneofField = &testAllTypes_OneofUint64{v}
}

func (x *TestAllTypes) SetOneofFloat(v float32) {
	x.xxx_hidden_OneofField = &testAllTypes_OneofFloat{v}
}

func (x *TestAllTypes) SetOneofDouble(v float64) {
	x.xxx_hidden_OneofField = &testAllTypes_OneofDouble{v}
}

func (x *TestAllTypes) SetOneofEnum(v TestAllTypes_NestedEnum) {
	x.xxx_hidden_OneofField = &testAllTypes_OneofEnum{v}
}

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

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

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

func (x *TestAllTypes) HasOptionalInt32() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 21)
}

func (x *TestAllTypes) HasOptionalInt64() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 22)
}

func (x *TestAllTypes) HasOptionalUint32() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 23)
}

func (x *TestAllTypes) HasOptionalUint64() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 24)
}

func (x *TestAllTypes) HasOptionalSint32() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 25)
}

func (x *TestAllTypes) HasOptionalSint64() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 26)
}

func (x *TestAllTypes) HasOptionalFixed32() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 27)
}

func (x *TestAllTypes) HasOptionalFixed64() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 28)
}

func (x *TestAllTypes) HasOptionalSfixed32() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 29)
}

func (x *TestAllTypes) HasOptionalSfixed64() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 30)
}

func (x *TestAllTypes) HasOptionalFloat() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[0]), 31)
}

func (x *TestAllTypes) HasOptionalDouble() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[1]), 32)
}

func (x *TestAllTypes) HasOptionalBool() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[1]), 33)
}

func (x *TestAllTypes) HasOptionalString() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[1]), 34)
}

func (x *TestAllTypes) HasOptionalBytes() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[1]), 35)
}

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

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

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

func (x *TestAllTypes) HasOptionalNestedEnum() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[1]), 39)
}

func (x *TestAllTypes) HasOptionalForeignEnum() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[1]), 40)
}

func (x *TestAllTypes) HasOptionalImportEnum() bool {
	if x == nil {
		return false
	}
	return protoimpl.X.Present(&(x.XXX_presence[1]), 41)
}

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

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

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

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

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

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

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

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

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

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

func (x *TestAllTypes) ClearSingularNestedMessage() {
	x.xxx_hidden_SingularNestedMessage = nil
}

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

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

func (x *TestAllTypes) ClearOptionalInt32() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 21)
	x.xxx_hidden_OptionalInt32 = 0
}

func (x *TestAllTypes) ClearOptionalInt64() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 22)
	x.xxx_hidden_OptionalInt64 = 0
}

func (x *TestAllTypes) ClearOptionalUint32() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 23)
	x.xxx_hidden_OptionalUint32 = 0
}

func (x *TestAllTypes) ClearOptionalUint64() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 24)
	x.xxx_hidden_OptionalUint64 = 0
}

func (x *TestAllTypes) ClearOptionalSint32() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 25)
	x.xxx_hidden_OptionalSint32 = 0
}

func (x *TestAllTypes) ClearOptionalSint64() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 26)
	x.xxx_hidden_OptionalSint64 = 0
}

func (x *TestAllTypes) ClearOptionalFixed32() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 27)
	x.xxx_hidden_OptionalFixed32 = 0
}

func (x *TestAllTypes) ClearOptionalFixed64() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 28)
	x.xxx_hidden_OptionalFixed64 = 0
}

func (x *TestAllTypes) ClearOptionalSfixed32() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 29)
	x.xxx_hidden_OptionalSfixed32 = 0
}

func (x *TestAllTypes) ClearOptionalSfixed64() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 30)
	x.xxx_hidden_OptionalSfixed64 = 0
}

func (x *TestAllTypes) ClearOptionalFloat() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[0]), 31)
	x.xxx_hidden_OptionalFloat = 0
}

func (x *TestAllTypes) ClearOptionalDouble() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[1]), 32)
	x.xxx_hidden_OptionalDouble = 0
}

func (x *TestAllTypes) ClearOptionalBool() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[1]), 33)
	x.xxx_hidden_OptionalBool = false
}

func (x *TestAllTypes) ClearOptionalString() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[1]), 34)
	x.xxx_hidden_OptionalString = nil
}

func (x *TestAllTypes) ClearOptionalBytes() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[1]), 35)
	x.xxx_hidden_OptionalBytes = nil
}

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

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

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

func (x *TestAllTypes) ClearOptionalNestedEnum() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[1]), 39)
	x.xxx_hidden_OptionalNestedEnum = TestAllTypes_FOO
}

func (x *TestAllTypes) ClearOptionalForeignEnum() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[1]), 40)
	x.xxx_hidden_OptionalForeignEnum = ForeignEnum_FOREIGN_ZERO
}

func (x *TestAllTypes) ClearOptionalImportEnum() {
	protoimpl.X.ClearPresent(&(x.XXX_presence[1]), 41)
	x.xxx_hidden_OptionalImportEnum = ImportEnum_IMPORT_ZERO
}

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

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

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

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

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

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

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

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

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

func (x *TestAllTypes) ClearOneofEnum() {
	if _, ok := x.xxx_hidden_OneofField.(*testAllTypes_OneofEnum); ok {
		x.xxx_hidden_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.xxx_hidden_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 xxx_hidden_OneofField:
	OneofUint32        *uint32
	OneofNestedMessage *TestAllTypes_NestedMessage
	OneofString        *string
	OneofBytes         []byte
	OneofBool          *bool
	OneofUint64        *uint64
	OneofFloat         *float32
	OneofDouble        *float64
	OneofEnum          *TestAllTypes_NestedEnum
	// -- end of xxx_hidden_OneofField
}

func (b0 TestAllTypes_builder) Build() *TestAllTypes {
	m0 := &TestAllTypes{}
	b, x := &b0, m0
	_, _ = b, x
	x.xxx_hidden_SingularInt32 = b.SingularInt32
	x.xxx_hidden_SingularInt64 = b.SingularInt64
	x.xxx_hidden_SingularUint32 = b.SingularUint32
	x.xxx_hidden_SingularUint64 = b.SingularUint64
	x.xxx_hidden_SingularSint32 = b.SingularSint32
	x.xxx_hidden_SingularSint64 = b.SingularSint64
	x.xxx_hidden_SingularFixed32 = b.SingularFixed32
	x.xxx_hidden_SingularFixed64 = b.SingularFixed64
	x.xxx_hidden_SingularSfixed32 = b.SingularSfixed32
	x.xxx_hidden_SingularSfixed64 = b.SingularSfixed64
	x.xxx_hidden_SingularFloat = b.SingularFloat
	x.xxx_hidden_SingularDouble = b.SingularDouble
	x.xxx_hidden_SingularBool = b.SingularBool
	x.xxx_hidden_SingularString = b.SingularString
	x.xxx_hidden_SingularBytes = b.SingularBytes
	x.xxx_hidden_SingularNestedMessage = b.SingularNestedMessage
	x.xxx_hidden_SingularForeignMessage = b.SingularForeignMessage
	x.xxx_hidden_SingularImportMessage = b.SingularImportMessage
	x.xxx_hidden_SingularNestedEnum = b.SingularNestedEnum
	x.xxx_hidden_SingularForeignEnum = b.SingularForeignEnum
	x.xxx_hidden_SingularImportEnum = b.SingularImportEnum
	if b.OptionalInt32 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 21, 81)
		x.xxx_hidden_OptionalInt32 = *b.OptionalInt32
	}
	if b.OptionalInt64 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 22, 81)
		x.xxx_hidden_OptionalInt64 = *b.OptionalInt64
	}
	if b.OptionalUint32 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 23, 81)
		x.xxx_hidden_OptionalUint32 = *b.OptionalUint32
	}
	if b.OptionalUint64 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 24, 81)
		x.xxx_hidden_OptionalUint64 = *b.OptionalUint64
	}
	if b.OptionalSint32 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 25, 81)
		x.xxx_hidden_OptionalSint32 = *b.OptionalSint32
	}
	if b.OptionalSint64 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 26, 81)
		x.xxx_hidden_OptionalSint64 = *b.OptionalSint64
	}
	if b.OptionalFixed32 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 27, 81)
		x.xxx_hidden_OptionalFixed32 = *b.OptionalFixed32
	}
	if b.OptionalFixed64 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 28, 81)
		x.xxx_hidden_OptionalFixed64 = *b.OptionalFixed64
	}
	if b.OptionalSfixed32 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 29, 81)
		x.xxx_hidden_OptionalSfixed32 = *b.OptionalSfixed32
	}
	if b.OptionalSfixed64 != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 30, 81)
		x.xxx_hidden_OptionalSfixed64 = *b.OptionalSfixed64
	}
	if b.OptionalFloat != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[0]), 31, 81)
		x.xxx_hidden_OptionalFloat = *b.OptionalFloat
	}
	if b.OptionalDouble != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[1]), 32, 81)
		x.xxx_hidden_OptionalDouble = *b.OptionalDouble
	}
	if b.OptionalBool != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[1]), 33, 81)
		x.xxx_hidden_OptionalBool = *b.OptionalBool
	}
	if b.OptionalString != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[1]), 34, 81)
		x.xxx_hidden_OptionalString = b.OptionalString
	}
	if b.OptionalBytes != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[1]), 35, 81)
		x.xxx_hidden_OptionalBytes = b.OptionalBytes
	}
	x.xxx_hidden_OptionalNestedMessage = b.OptionalNestedMessage
	x.xxx_hidden_OptionalForeignMessage = b.OptionalForeignMessage
	x.xxx_hidden_OptionalImportMessage = b.OptionalImportMessage
	if b.OptionalNestedEnum != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[1]), 39, 81)
		x.xxx_hidden_OptionalNestedEnum = *b.OptionalNestedEnum
	}
	if b.OptionalForeignEnum != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[1]), 40, 81)
		x.xxx_hidden_OptionalForeignEnum = *b.OptionalForeignEnum
	}
	if b.OptionalImportEnum != nil {
		protoimpl.X.SetPresentNonAtomic(&(x.XXX_presence[1]), 41, 81)
		x.xxx_hidden_OptionalImportEnum = *b.OptionalImportEnum
	}
	x.xxx_hidden_RepeatedInt32 = b.RepeatedInt32
	x.xxx_hidden_RepeatedInt64 = b.RepeatedInt64
	x.xxx_hidden_RepeatedUint32 = b.RepeatedUint32
	x.xxx_hidden_RepeatedUint64 = b.RepeatedUint64
	x.xxx_hidden_RepeatedSint32 = b.RepeatedSint32
	x.xxx_hidden_RepeatedSint64 = b.RepeatedSint64
	x.xxx_hidden_RepeatedFixed32 = b.RepeatedFixed32
	x.xxx_hidden_RepeatedFixed64 = b.RepeatedFixed64
	x.xxx_hidden_RepeatedSfixed32 = b.RepeatedSfixed32
	x.xxx_hidden_RepeatedSfixed64 = b.RepeatedSfixed64
	x.xxx_hidden_RepeatedFloat = b.RepeatedFloat
	x.xxx_hidden_RepeatedDouble = b.RepeatedDouble
	x.xxx_hidden_RepeatedBool = b.RepeatedBool
	x.xxx_hidden_RepeatedString = b.RepeatedString
	x.xxx_hidden_RepeatedBytes = b.RepeatedBytes
	x.xxx_hidden_RepeatedNestedMessage = &b.RepeatedNestedMessage
	x.xxx_hidden_RepeatedForeignMessage = &b.RepeatedForeignMessage
	x.xxx_hidden_RepeatedImportmessage = &b.RepeatedImportmessage
	x.xxx_hidden_RepeatedNestedEnum = b.RepeatedNestedEnum
	x.xxx_hidden_RepeatedForeignEnum = b.RepeatedForeignEnum
	x.xxx_hidden_RepeatedImportenum = b.RepeatedImportenum
	x.xxx_hidden_MapInt32Int32 = b.MapInt32Int32
	x.xxx_hidden_MapInt64Int64 = b.MapInt64Int64
	x.xxx_hidden_MapUint32Uint32 = b.MapUint32Uint32
	x.xxx_hidden_MapUint64Uint64 = b.MapUint64Uint64
	x.xxx_hidden_MapSint32Sint32 = b.MapSint32Sint32
	x.xxx_hidden_MapSint64Sint64 = b.MapSint64Sint64
	x.xxx_hidden_MapFixed32Fixed32 = b.MapFixed32Fixed32
	x.xxx_hidden_MapFixed64Fixed64 = b.MapFixed64Fixed64
	x.xxx_hidden_MapSfixed32Sfixed32 = b.MapSfixed32Sfixed32
	x.xxx_hidden_MapSfixed64Sfixed64 = b.MapSfixed64Sfixed64
	x.xxx_hidden_MapInt32Float = b.MapInt32Float
	x.xxx_hidden_MapInt32Double = b.MapInt32Double
	x.xxx_hidden_MapBoolBool = b.MapBoolBool
	x.xxx_hidden_MapStringString = b.MapStringString
	x.xxx_hidden_MapStringBytes = b.MapStringBytes
	x.xxx_hidden_MapStringNestedMessage = b.MapStringNestedMessage
	x.xxx_hidden_MapStringNestedEnum = b.MapStringNestedEnum
	if b.OneofUint32 != nil {
		x.xxx_hidden_OneofField = &testAllTypes_OneofUint32{*b.OneofUint32}
	}
	if b.OneofNestedMessage != nil {
		x.xxx_hidden_OneofField = &testAllTypes_OneofNestedMessage{b.OneofNestedMessage}
	}
	if b.OneofString != nil {
		x.xxx_hidden_OneofField = &testAllTypes_OneofString{*b.OneofString}
	}
	if b.OneofBytes != nil {
		x.xxx_hidden_OneofField = &testAllTypes_OneofBytes{b.OneofBytes}
	}
	if b.OneofBool != nil {
		x.xxx_hidden_OneofField = &testAllTypes_OneofBool{*b.OneofBool}
	}
	if b.OneofUint64 != nil {
		x.xxx_hidden_OneofField = &testAllTypes_OneofUint64{*b.OneofUint64}
	}
	if b.OneofFloat != nil {
		x.xxx_hidden_OneofField = &testAllTypes_OneofFloat{*b.OneofFloat}
	}
	if b.OneofDouble != nil {
		x.xxx_hidden_OneofField = &testAllTypes_OneofDouble{*b.OneofDouble}
	}
	if b.OneofEnum != nil {
		x.xxx_hidden_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:"opaque.v1"`
	xxx_hidden_C  int32                  `protobuf:"varint,1,opt,name=c,proto3"`
	xxx_hidden_D  int32                  `protobuf:"varint,2,opt,name=d,proto3"`
	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.xxx_hidden_C
	}
	return 0
}

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

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

func (x *ForeignMessage) SetD(v int32) {
	x.xxx_hidden_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.xxx_hidden_C = b.C
	x.xxx_hidden_D = b.D
	return m0
}

type TestAllTypes_NestedMessage struct {
	state                  protoimpl.MessageState `protogen:"opaque.v1"`
	xxx_hidden_A           int32                  `protobuf:"varint,1,opt,name=a,proto3"`
	xxx_hidden_Corecursive *TestAllTypes          `protobuf:"bytes,2,opt,name=corecursive,proto3"`
	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.xxx_hidden_A
	}
	return 0
}

func (x *TestAllTypes_NestedMessage) GetCorecursive() *TestAllTypes {
	if x != nil {
		return x.xxx_hidden_Corecursive
	}
	return nil
}

func (x *TestAllTypes_NestedMessage) SetA(v int32) {
	x.xxx_hidden_A = v
}

func (x *TestAllTypes_NestedMessage) SetCorecursive(v *TestAllTypes) {
	x.xxx_hidden_Corecursive = v
}

func (x *TestAllTypes_NestedMessage) HasCorecursive() bool {
	if x == nil {
		return false
	}
	return x.xxx_hidden_Corecursive != nil
}

func (x *TestAllTypes_NestedMessage) ClearCorecursive() {
	x.xxx_hidden_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.xxx_hidden_A = b.A
	x.xxx_hidden_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
}