encoding/textpb/testprotos/pb3/test.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: encoding/textpb/testprotos/pb3/test.proto

package pb3

import (
	proto "github.com/golang/protobuf/proto"
	protoreflect "github.com/golang/protobuf/v2/reflect/protoreflect"
	prototype "github.com/golang/protobuf/v2/reflect/prototype"
	protoimpl "github.com/golang/protobuf/v2/runtime/protoimpl"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

type Enum int32

const (
	Enum_ZERO Enum = 0
	Enum_ONE  Enum = 1
	Enum_TWO  Enum = 2
	Enum_TEN  Enum = 10
)

func (e Enum) Type() protoreflect.EnumType {
	return xxx_Test_protoFile_EnumTypes[0]
}
func (e Enum) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(e)
}

var Enum_name = map[int32]string{
	0:  "ZERO",
	1:  "ONE",
	2:  "TWO",
	10: "TEN",
}

var Enum_value = map[string]int32{
	"ZERO": 0,
	"ONE":  1,
	"TWO":  2,
	"TEN":  10,
}

func (x Enum) String() string {
	return proto.EnumName(Enum_name, int32(x))
}

func (Enum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0854715c5b41c422, []int{0}
}

type Enums_NestedEnum int32

const (
	Enums_CERO Enums_NestedEnum = 0
	Enums_UNO  Enums_NestedEnum = 1
	Enums_DOS  Enums_NestedEnum = 2
	Enums_DIEZ Enums_NestedEnum = 10
)

func (e Enums_NestedEnum) Type() protoreflect.EnumType {
	return xxx_Test_protoFile_EnumTypes[1]
}
func (e Enums_NestedEnum) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(e)
}

var Enums_NestedEnum_name = map[int32]string{
	0:  "CERO",
	1:  "UNO",
	2:  "DOS",
	10: "DIEZ",
}

var Enums_NestedEnum_value = map[string]int32{
	"CERO": 0,
	"UNO":  1,
	"DOS":  2,
	"DIEZ": 10,
}

func (x Enums_NestedEnum) String() string {
	return proto.EnumName(Enums_NestedEnum_name, int32(x))
}

func (Enums_NestedEnum) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0854715c5b41c422, []int{1, 0}
}

// Scalars contains scalar field types.
type Scalars struct {
	SBool                bool     `protobuf:"varint,1,opt,name=s_bool,json=sBool,proto3" json:"s_bool,omitempty"`
	SInt32               int32    `protobuf:"varint,2,opt,name=s_int32,json=sInt32,proto3" json:"s_int32,omitempty"`
	SInt64               int64    `protobuf:"varint,3,opt,name=s_int64,json=sInt64,proto3" json:"s_int64,omitempty"`
	SUint32              uint32   `protobuf:"varint,4,opt,name=s_uint32,json=sUint32,proto3" json:"s_uint32,omitempty"`
	SUint64              uint64   `protobuf:"varint,5,opt,name=s_uint64,json=sUint64,proto3" json:"s_uint64,omitempty"`
	SSint32              int32    `protobuf:"zigzag32,6,opt,name=s_sint32,json=sSint32,proto3" json:"s_sint32,omitempty"`
	SSint64              int64    `protobuf:"zigzag64,7,opt,name=s_sint64,json=sSint64,proto3" json:"s_sint64,omitempty"`
	SFixed32             uint32   `protobuf:"fixed32,8,opt,name=s_fixed32,json=sFixed32,proto3" json:"s_fixed32,omitempty"`
	SFixed64             uint64   `protobuf:"fixed64,9,opt,name=s_fixed64,json=sFixed64,proto3" json:"s_fixed64,omitempty"`
	SSfixed32            int32    `protobuf:"fixed32,10,opt,name=s_sfixed32,json=sSfixed32,proto3" json:"s_sfixed32,omitempty"`
	SSfixed64            int64    `protobuf:"fixed64,11,opt,name=s_sfixed64,json=sSfixed64,proto3" json:"s_sfixed64,omitempty"`
	SFloat               float32  `protobuf:"fixed32,20,opt,name=s_float,json=sFloat,proto3" json:"s_float,omitempty"`
	SDouble              float64  `protobuf:"fixed64,21,opt,name=s_double,json=sDouble,proto3" json:"s_double,omitempty"`
	SBytes               []byte   `protobuf:"bytes,14,opt,name=s_bytes,json=sBytes,proto3" json:"s_bytes,omitempty"`
	SString              string   `protobuf:"bytes,13,opt,name=s_string,json=sString,proto3" json:"s_string,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type xxx_Scalars struct{ m *Scalars }

func (m *Scalars) ProtoReflect() protoreflect.Message {
	return xxx_Scalars{m}
}
func (m xxx_Scalars) Type() protoreflect.MessageType {
	return xxx_Test_protoFile_MessageTypes[0].Type
}
func (m xxx_Scalars) KnownFields() protoreflect.KnownFields {
	return xxx_Test_protoFile_MessageTypes[0].KnownFieldsOf(m.m)
}
func (m xxx_Scalars) UnknownFields() protoreflect.UnknownFields {
	return xxx_Test_protoFile_MessageTypes[0].UnknownFieldsOf(m.m)
}
func (m xxx_Scalars) Interface() protoreflect.ProtoMessage {
	return m.m
}

func (m *Scalars) Reset()         { *m = Scalars{} }
func (m *Scalars) String() string { return proto.CompactTextString(m) }
func (*Scalars) ProtoMessage()    {}
func (*Scalars) Descriptor() ([]byte, []int) {
	return fileDescriptor_0854715c5b41c422, []int{0}
}

func (m *Scalars) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Scalars.Unmarshal(m, b)
}
func (m *Scalars) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Scalars.Marshal(b, m, deterministic)
}
func (m *Scalars) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Scalars.Merge(m, src)
}
func (m *Scalars) XXX_Size() int {
	return xxx_messageInfo_Scalars.Size(m)
}
func (m *Scalars) XXX_DiscardUnknown() {
	xxx_messageInfo_Scalars.DiscardUnknown(m)
}

var xxx_messageInfo_Scalars proto.InternalMessageInfo

func (m *Scalars) GetSBool() bool {
	if m != nil {
		return m.SBool
	}
	return false
}

func (m *Scalars) GetSInt32() int32 {
	if m != nil {
		return m.SInt32
	}
	return 0
}

func (m *Scalars) GetSInt64() int64 {
	if m != nil {
		return m.SInt64
	}
	return 0
}

func (m *Scalars) GetSUint32() uint32 {
	if m != nil {
		return m.SUint32
	}
	return 0
}

func (m *Scalars) GetSUint64() uint64 {
	if m != nil {
		return m.SUint64
	}
	return 0
}

func (m *Scalars) GetSSint32() int32 {
	if m != nil {
		return m.SSint32
	}
	return 0
}

func (m *Scalars) GetSSint64() int64 {
	if m != nil {
		return m.SSint64
	}
	return 0
}

func (m *Scalars) GetSFixed32() uint32 {
	if m != nil {
		return m.SFixed32
	}
	return 0
}

func (m *Scalars) GetSFixed64() uint64 {
	if m != nil {
		return m.SFixed64
	}
	return 0
}

func (m *Scalars) GetSSfixed32() int32 {
	if m != nil {
		return m.SSfixed32
	}
	return 0
}

func (m *Scalars) GetSSfixed64() int64 {
	if m != nil {
		return m.SSfixed64
	}
	return 0
}

func (m *Scalars) GetSFloat() float32 {
	if m != nil {
		return m.SFloat
	}
	return 0
}

func (m *Scalars) GetSDouble() float64 {
	if m != nil {
		return m.SDouble
	}
	return 0
}

func (m *Scalars) GetSBytes() []byte {
	if m != nil {
		return m.SBytes
	}
	return nil
}

func (m *Scalars) GetSString() string {
	if m != nil {
		return m.SString
	}
	return ""
}

// Message contains enum fields.
type Enums struct {
	SEnum                Enum             `protobuf:"varint,1,opt,name=s_enum,json=sEnum,proto3,enum=pb3.Enum" json:"s_enum,omitempty"`
	SNestedEnum          Enums_NestedEnum `protobuf:"varint,3,opt,name=s_nested_enum,json=sNestedEnum,proto3,enum=pb3.Enums_NestedEnum" json:"s_nested_enum,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

type xxx_Enums struct{ m *Enums }

func (m *Enums) ProtoReflect() protoreflect.Message {
	return xxx_Enums{m}
}
func (m xxx_Enums) Type() protoreflect.MessageType {
	return xxx_Test_protoFile_MessageTypes[1].Type
}
func (m xxx_Enums) KnownFields() protoreflect.KnownFields {
	return xxx_Test_protoFile_MessageTypes[1].KnownFieldsOf(m.m)
}
func (m xxx_Enums) UnknownFields() protoreflect.UnknownFields {
	return xxx_Test_protoFile_MessageTypes[1].UnknownFieldsOf(m.m)
}
func (m xxx_Enums) Interface() protoreflect.ProtoMessage {
	return m.m
}

func (m *Enums) Reset()         { *m = Enums{} }
func (m *Enums) String() string { return proto.CompactTextString(m) }
func (*Enums) ProtoMessage()    {}
func (*Enums) Descriptor() ([]byte, []int) {
	return fileDescriptor_0854715c5b41c422, []int{1}
}

func (m *Enums) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Enums.Unmarshal(m, b)
}
func (m *Enums) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Enums.Marshal(b, m, deterministic)
}
func (m *Enums) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Enums.Merge(m, src)
}
func (m *Enums) XXX_Size() int {
	return xxx_messageInfo_Enums.Size(m)
}
func (m *Enums) XXX_DiscardUnknown() {
	xxx_messageInfo_Enums.DiscardUnknown(m)
}

var xxx_messageInfo_Enums proto.InternalMessageInfo

func (m *Enums) GetSEnum() Enum {
	if m != nil {
		return m.SEnum
	}
	return Enum_ZERO
}

func (m *Enums) GetSNestedEnum() Enums_NestedEnum {
	if m != nil {
		return m.SNestedEnum
	}
	return Enums_CERO
}

// Message contains nested message field.
type Nests struct {
	SNested              *Nested  `protobuf:"bytes,1,opt,name=s_nested,json=sNested,proto3" json:"s_nested,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type xxx_Nests struct{ m *Nests }

func (m *Nests) ProtoReflect() protoreflect.Message {
	return xxx_Nests{m}
}
func (m xxx_Nests) Type() protoreflect.MessageType {
	return xxx_Test_protoFile_MessageTypes[2].Type
}
func (m xxx_Nests) KnownFields() protoreflect.KnownFields {
	return xxx_Test_protoFile_MessageTypes[2].KnownFieldsOf(m.m)
}
func (m xxx_Nests) UnknownFields() protoreflect.UnknownFields {
	return xxx_Test_protoFile_MessageTypes[2].UnknownFieldsOf(m.m)
}
func (m xxx_Nests) Interface() protoreflect.ProtoMessage {
	return m.m
}

func (m *Nests) Reset()         { *m = Nests{} }
func (m *Nests) String() string { return proto.CompactTextString(m) }
func (*Nests) ProtoMessage()    {}
func (*Nests) Descriptor() ([]byte, []int) {
	return fileDescriptor_0854715c5b41c422, []int{2}
}

func (m *Nests) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Nests.Unmarshal(m, b)
}
func (m *Nests) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Nests.Marshal(b, m, deterministic)
}
func (m *Nests) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Nests.Merge(m, src)
}
func (m *Nests) XXX_Size() int {
	return xxx_messageInfo_Nests.Size(m)
}
func (m *Nests) XXX_DiscardUnknown() {
	xxx_messageInfo_Nests.DiscardUnknown(m)
}

var xxx_messageInfo_Nests proto.InternalMessageInfo

func (m *Nests) GetSNested() *Nested {
	if m != nil {
		return m.SNested
	}
	return nil
}

// Message type used as submessage.
type Nested struct {
	SString              string   `protobuf:"bytes,1,opt,name=s_string,json=sString,proto3" json:"s_string,omitempty"`
	SNested              *Nested  `protobuf:"bytes,2,opt,name=s_nested,json=sNested,proto3" json:"s_nested,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

type xxx_Nested struct{ m *Nested }

func (m *Nested) ProtoReflect() protoreflect.Message {
	return xxx_Nested{m}
}
func (m xxx_Nested) Type() protoreflect.MessageType {
	return xxx_Test_protoFile_MessageTypes[3].Type
}
func (m xxx_Nested) KnownFields() protoreflect.KnownFields {
	return xxx_Test_protoFile_MessageTypes[3].KnownFieldsOf(m.m)
}
func (m xxx_Nested) UnknownFields() protoreflect.UnknownFields {
	return xxx_Test_protoFile_MessageTypes[3].UnknownFieldsOf(m.m)
}
func (m xxx_Nested) Interface() protoreflect.ProtoMessage {
	return m.m
}

func (m *Nested) Reset()         { *m = Nested{} }
func (m *Nested) String() string { return proto.CompactTextString(m) }
func (*Nested) ProtoMessage()    {}
func (*Nested) Descriptor() ([]byte, []int) {
	return fileDescriptor_0854715c5b41c422, []int{3}
}

func (m *Nested) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Nested.Unmarshal(m, b)
}
func (m *Nested) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Nested.Marshal(b, m, deterministic)
}
func (m *Nested) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Nested.Merge(m, src)
}
func (m *Nested) XXX_Size() int {
	return xxx_messageInfo_Nested.Size(m)
}
func (m *Nested) XXX_DiscardUnknown() {
	xxx_messageInfo_Nested.DiscardUnknown(m)
}

var xxx_messageInfo_Nested proto.InternalMessageInfo

func (m *Nested) GetSString() string {
	if m != nil {
		return m.SString
	}
	return ""
}

func (m *Nested) GetSNested() *Nested {
	if m != nil {
		return m.SNested
	}
	return nil
}

func init() {
	proto.RegisterFile("encoding/textpb/testprotos/pb3/test.proto", fileDescriptor_0854715c5b41c422)
	proto.RegisterEnum("pb3.Enum", Enum_name, Enum_value)
	proto.RegisterEnum("pb3.Enums_NestedEnum", Enums_NestedEnum_name, Enums_NestedEnum_value)
	proto.RegisterType((*Scalars)(nil), "pb3.Scalars")
	proto.RegisterType((*Enums)(nil), "pb3.Enums")
	proto.RegisterType((*Nests)(nil), "pb3.Nests")
	proto.RegisterType((*Nested)(nil), "pb3.Nested")
}

var fileDescriptor_0854715c5b41c422 = []byte{
	// 503 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xdf, 0xab, 0xd3, 0x30,
	0x14, 0xc7, 0xcd, 0xba, 0xb6, 0x5b, 0xe6, 0xbd, 0xd6, 0xe0, 0x30, 0x22, 0x42, 0xd8, 0x83, 0x44,
	0x85, 0x15, 0xda, 0x52, 0x10, 0xc4, 0x87, 0xb9, 0x5d, 0xb8, 0x08, 0x1b, 0x64, 0x5e, 0x84, 0xbd,
	0x94, 0x75, 0xeb, 0xe6, 0xa0, 0x6b, 0xc6, 0x4e, 0x2a, 0xd7, 0xff, 0xc4, 0x27, 0xff, 0x56, 0x49,
	0xb2, 0x9f, 0x0f, 0xfa, 0xd4, 0xf3, 0xed, 0x27, 0xdf, 0x73, 0xbe, 0x87, 0x10, 0xfc, 0xae, 0xa8,
	0x16, 0x72, 0xb9, 0xa9, 0xd6, 0xa1, 0x2a, 0x1e, 0xd5, 0x2e, 0x0f, 0x55, 0x01, 0x6a, 0xb7, 0x97,
	0x4a, 0x42, 0xb8, 0xcb, 0x63, 0x23, 0xfb, 0x46, 0x13, 0x67, 0x97, 0xc7, 0xbd, 0x3f, 0x0e, 0xf6,
	0xa7, 0x8b, 0x79, 0x39, 0xdf, 0x03, 0xe9, 0x62, 0x0f, 0xb2, 0x5c, 0xca, 0x92, 0x22, 0x86, 0x78,
	0x4b, 0xb8, 0x30, 0x90, 0xb2, 0x24, 0x2f, 0xb1, 0x0f, 0xd9, 0xa6, 0x52, 0x71, 0x44, 0x1b, 0x0c,
	0x71, 0x57, 0x78, 0x70, 0xaf, 0xd5, 0x09, 0xa4, 0x09, 0x75, 0x18, 0xe2, 0x8e, 0x05, 0x69, 0x42,
	0x5e, 0xe1, 0x16, 0x64, 0xb5, 0xb5, 0x34, 0x19, 0xe2, 0x37, 0xc2, 0x87, 0x07, 0x23, 0xcf, 0x28,
	0x4d, 0xa8, 0xcb, 0x10, 0x6f, 0x1e, 0xd0, 0xd1, 0x05, 0xd6, 0xe5, 0x31, 0xc4, 0x9f, 0x0b, 0x1f,
	0xa6, 0x17, 0x2e, 0xb0, 0x2e, 0x9f, 0x21, 0x4e, 0x0e, 0x28, 0x4d, 0xc8, 0x6b, 0xdc, 0x86, 0x6c,
	0xb5, 0x79, 0x2c, 0x96, 0x71, 0x44, 0x5b, 0x0c, 0x71, 0x5f, 0xb4, 0xe0, 0xce, 0xea, 0x0b, 0x98,
	0x26, 0xb4, 0xcd, 0x10, 0xf7, 0x8e, 0x30, 0x4d, 0xc8, 0x1b, 0x8c, 0x21, 0x83, 0xa3, 0x15, 0x33,
	0xc4, 0x9f, 0x89, 0x36, 0x4c, 0x0f, 0x3f, 0x2e, 0x71, 0x9a, 0xd0, 0x0e, 0x43, 0x3c, 0x38, 0xe1,
	0x34, 0xb1, 0xcb, 0xaf, 0x4a, 0x39, 0x57, 0xf4, 0x05, 0x43, 0xbc, 0x21, 0x3c, 0xb8, 0xd3, 0xca,
	0x66, 0x5d, 0xca, 0x3a, 0x2f, 0x0b, 0xda, 0x65, 0x88, 0x23, 0xe1, 0xc3, 0xd0, 0x48, 0xeb, 0xc9,
	0x7f, 0xa9, 0x02, 0xe8, 0x2d, 0x43, 0xfc, 0xa9, 0xf0, 0x60, 0xa0, 0xd5, 0x61, 0x3f, 0xb5, 0xdf,
	0x54, 0x6b, 0x7a, 0xc3, 0x10, 0x6f, 0xeb, 0xfd, 0x8c, 0xec, 0xfd, 0x46, 0xd8, 0x1d, 0x55, 0xf5,
	0x16, 0x08, 0xd3, 0xd7, 0x53, 0x54, 0xf5, 0xd6, 0x5c, 0xcf, 0x6d, 0xd4, 0xee, 0xef, 0xf2, 0xb8,
	0xaf, 0x99, 0x70, 0x41, 0x7f, 0xc8, 0x47, 0x7c, 0x03, 0x59, 0x55, 0x80, 0x2a, 0x96, 0xf6, 0xa0,
	0x63, 0x0e, 0x76, 0x4f, 0x07, 0xa1, 0x3f, 0x36, 0xd4, 0x98, 0x3a, 0x70, 0x16, 0xbd, 0x08, 0xe3,
	0xb3, 0x22, 0x2d, 0xdc, 0xfc, 0x32, 0x12, 0x93, 0xe0, 0x09, 0xf1, 0xb1, 0xf3, 0x30, 0x9e, 0x04,
	0x48, 0x17, 0xc3, 0xc9, 0x34, 0x68, 0x68, 0x36, 0xbc, 0x1f, 0xcd, 0x02, 0xdc, 0x0b, 0xb1, 0xab,
	0x3d, 0x40, 0xde, 0xea, 0xf8, 0x76, 0xae, 0xc9, 0xd6, 0x89, 0x3a, 0x66, 0xa4, 0xed, 0x28, 0xfc,
	0xc3, 0xa0, 0xde, 0x57, 0xec, 0xd9, 0xea, 0x6a, 0x61, 0x74, 0xb5, 0xf0, 0x55, 0xb3, 0xc6, 0xbf,
	0x9b, 0xbd, 0xff, 0x80, 0x9b, 0xc7, 0xac, 0xb3, 0x53, 0xd6, 0xc9, 0x78, 0x64, 0xb3, 0x7e, 0xfb,
	0x3e, 0x09, 0x1a, 0xa6, 0x18, 0x8d, 0x03, 0x3c, 0xf8, 0x3c, 0xfb, 0xb4, 0xde, 0xa8, 0x1f, 0x75,
	0xde, 0x5f, 0xc8, 0x6d, 0xb8, 0x96, 0xe5, 0xbc, 0x5a, 0x87, 0xe6, 0x19, 0xe4, 0xf5, 0x2a, 0xfc,
	0x19, 0x85, 0xff, 0x7f, 0x36, 0xb9, 0x67, 0xea, 0xf8, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0xd9,
	0x7d, 0x94, 0x3a, 0x5f, 0x03, 0x00, 0x00,
}

func init() {
	xxx_Test_protoFile_FileDesc.Enums = xxx_Test_protoFile_EnumDescs[0:1]
	xxx_Test_protoFile_FileDesc.Messages = xxx_Test_protoFile_MessageDescs[0:4]
	xxx_Test_protoFile_MessageDescs[1].Enums = xxx_Test_protoFile_EnumDescs[1:2]
	xxx_Test_protoFile_MessageDescs[1].Fields[0].EnumType = xxx_Test_protoFile_EnumTypes[0]
	xxx_Test_protoFile_MessageDescs[1].Fields[1].EnumType = xxx_Test_protoFile_EnumTypes[1]
	xxx_Test_protoFile_MessageDescs[2].Fields[0].MessageType = xxx_Test_protoFile_MessageTypes[3].Type
	xxx_Test_protoFile_MessageDescs[3].Fields[1].MessageType = xxx_Test_protoFile_MessageTypes[3].Type
	var err error
	Test_protoFile, err = prototype.NewFile(&xxx_Test_protoFile_FileDesc)
	if err != nil {
		panic(err)
	}
}

const _ = protoimpl.EnforceVersion(protoimpl.Version - 0)

var Test_protoFile protoreflect.FileDescriptor

var xxx_Test_protoFile_FileDesc = prototype.File{
	Syntax:  protoreflect.Proto3,
	Path:    "encoding/textpb/testprotos/pb3/test.proto",
	Package: "pb3",
}
var xxx_Test_protoFile_EnumTypes = [2]protoreflect.EnumType{
	prototype.GoEnum(
		xxx_Test_protoFile_EnumDescs[0].Reference(),
		func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.Enum {
			return Enum(n)
		},
	),
	prototype.GoEnum(
		xxx_Test_protoFile_EnumDescs[1].Reference(),
		func(_ protoreflect.EnumType, n protoreflect.EnumNumber) protoreflect.Enum {
			return Enums_NestedEnum(n)
		},
	),
}
var xxx_Test_protoFile_EnumDescs = [2]prototype.Enum{
	{
		Name: "Enum",
		Values: []prototype.EnumValue{
			{Name: "ZERO", Number: 0},
			{Name: "ONE", Number: 1},
			{Name: "TWO", Number: 2},
			{Name: "TEN", Number: 10},
		},
	},
	{
		Name: "NestedEnum",
		Values: []prototype.EnumValue{
			{Name: "CERO", Number: 0},
			{Name: "UNO", Number: 1},
			{Name: "DOS", Number: 2},
			{Name: "DIEZ", Number: 10},
		},
	},
}
var xxx_Test_protoFile_MessageTypes = [4]protoimpl.MessageType{
	{Type: prototype.GoMessage(
		xxx_Test_protoFile_MessageDescs[0].Reference(),
		func(protoreflect.MessageType) protoreflect.Message {
			return xxx_Scalars{new(Scalars)}
		},
	)},
	{Type: prototype.GoMessage(
		xxx_Test_protoFile_MessageDescs[1].Reference(),
		func(protoreflect.MessageType) protoreflect.Message {
			return xxx_Enums{new(Enums)}
		},
	)},
	{Type: prototype.GoMessage(
		xxx_Test_protoFile_MessageDescs[2].Reference(),
		func(protoreflect.MessageType) protoreflect.Message {
			return xxx_Nests{new(Nests)}
		},
	)},
	{Type: prototype.GoMessage(
		xxx_Test_protoFile_MessageDescs[3].Reference(),
		func(protoreflect.MessageType) protoreflect.Message {
			return xxx_Nested{new(Nested)}
		},
	)},
}
var xxx_Test_protoFile_MessageDescs = [4]prototype.Message{
	{
		Name: "Scalars",
		Fields: []prototype.Field{
			{
				Name:        "s_bool",
				Number:      1,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.BoolKind,
				JSONName:    "sBool",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_int32",
				Number:      2,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Int32Kind,
				JSONName:    "sInt32",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_int64",
				Number:      3,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Int64Kind,
				JSONName:    "sInt64",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_uint32",
				Number:      4,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Uint32Kind,
				JSONName:    "sUint32",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_uint64",
				Number:      5,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Uint64Kind,
				JSONName:    "sUint64",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_sint32",
				Number:      6,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Sint32Kind,
				JSONName:    "sSint32",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_sint64",
				Number:      7,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Sint64Kind,
				JSONName:    "sSint64",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_fixed32",
				Number:      8,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Fixed32Kind,
				JSONName:    "sFixed32",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_fixed64",
				Number:      9,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Fixed64Kind,
				JSONName:    "sFixed64",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_sfixed32",
				Number:      10,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Sfixed32Kind,
				JSONName:    "sSfixed32",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_sfixed64",
				Number:      11,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.Sfixed64Kind,
				JSONName:    "sSfixed64",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_float",
				Number:      20,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.FloatKind,
				JSONName:    "sFloat",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_double",
				Number:      21,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.DoubleKind,
				JSONName:    "sDouble",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_bytes",
				Number:      14,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.BytesKind,
				JSONName:    "sBytes",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_string",
				Number:      13,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.StringKind,
				JSONName:    "sString",
				IsPacked:    prototype.False,
			},
		},
	},
	{
		Name: "Enums",
		Fields: []prototype.Field{
			{
				Name:        "s_enum",
				Number:      1,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.EnumKind,
				JSONName:    "sEnum",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_nested_enum",
				Number:      3,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.EnumKind,
				JSONName:    "sNestedEnum",
				IsPacked:    prototype.False,
			},
		},
	},
	{
		Name: "Nests",
		Fields: []prototype.Field{
			{
				Name:        "s_nested",
				Number:      1,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.MessageKind,
				JSONName:    "sNested",
				IsPacked:    prototype.False,
			},
		},
	},
	{
		Name: "Nested",
		Fields: []prototype.Field{
			{
				Name:        "s_string",
				Number:      1,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.StringKind,
				JSONName:    "sString",
				IsPacked:    prototype.False,
			},
			{
				Name:        "s_nested",
				Number:      2,
				Cardinality: protoreflect.Optional,
				Kind:        protoreflect.MessageKind,
				JSONName:    "sNested",
				IsPacked:    prototype.False,
			},
		},
	},
}