diff --git a/encoding/protojson/decode_test.go b/encoding/protojson/decode_test.go index 4355b754..8d827627 100644 --- a/encoding/protojson/decode_test.go +++ b/encoding/protojson/decode_test.go @@ -19,6 +19,7 @@ import ( weakpb "google.golang.org/protobuf/internal/testprotos/test/weak1" pb2 "google.golang.org/protobuf/internal/testprotos/textpb2" pb3 "google.golang.org/protobuf/internal/testprotos/textpb3" + pbeditions "google.golang.org/protobuf/internal/testprotos/textpbeditions" "google.golang.org/protobuf/types/known/anypb" "google.golang.org/protobuf/types/known/durationpb" "google.golang.org/protobuf/types/known/emptypb" @@ -84,6 +85,52 @@ func TestUnmarshal(t *testing.T) { OptBytes: []byte{}, OptString: proto.String(""), }, + }, { + inputMessage: &pbeditions.Scalars{}, + inputText: "{}", + wantMessage: &pbeditions.Scalars{}, + }, { + desc: "unexpected value instead of EOF", + inputMessage: &pbeditions.Scalars{}, + inputText: "{} {}", + wantErr: `(line 1:4): unexpected token {`, + }, { + desc: "proto2 optional scalars set to zero values", + inputMessage: &pbeditions.Scalars{}, + inputText: `{ + "optBool": false, + "optInt32": 0, + "optInt64": 0, + "optUint32": 0, + "optUint64": 0, + "optSint32": 0, + "optSint64": 0, + "optFixed32": 0, + "optFixed64": 0, + "optSfixed32": 0, + "optSfixed64": 0, + "optFloat": 0, + "optDouble": 0, + "optBytes": "", + "optString": "" +}`, + wantMessage: &pbeditions.Scalars{ + OptBool: proto.Bool(false), + OptInt32: proto.Int32(0), + OptInt64: proto.Int64(0), + OptUint32: proto.Uint32(0), + OptUint64: proto.Uint64(0), + OptSint32: proto.Int32(0), + OptSint64: proto.Int64(0), + OptFixed32: proto.Uint32(0), + OptFixed64: proto.Uint64(0), + OptSfixed32: proto.Int32(0), + OptSfixed64: proto.Int64(0), + OptFloat: proto.Float32(0), + OptDouble: proto.Float64(0), + OptBytes: []byte{}, + OptString: proto.String(""), + }, }, { desc: "proto3 scalars set to zero values", inputMessage: &pb3.Scalars{}, @@ -155,6 +202,83 @@ func TestUnmarshal(t *testing.T) { "optString": null }`, wantMessage: &pb2.Scalars{}, + }, { + desc: "protoeditions implicit scalars set to null", + inputMessage: &pbeditions.ImplicitScalars{}, + inputText: `{ + "sBool": null, + "sInt32": null, + "sInt64": null, + "sUint32": null, + "sUint64": null, + "sSint32": null, + "sSint64": null, + "sFixed32": null, + "sFixed64": null, + "sSfixed32": null, + "sSfixed64": null, + "sFloat": null, + "sDouble": null, + "sBytes": null, + "sString": null +}`, + wantMessage: &pbeditions.ImplicitScalars{}, + }, { + desc: "boolean", + inputMessage: &pbeditions.ImplicitScalars{}, + inputText: `{"sBool": true}`, + wantMessage: &pbeditions.ImplicitScalars{ + SBool: true, + }, + }, { + desc: "not boolean", + inputMessage: &pbeditions.ImplicitScalars{}, + inputText: `{"sBool": "true"}`, + wantErr: `invalid value for bool type: "true"`, + }, { + desc: "float and double", + inputMessage: &pbeditions.ImplicitScalars{}, + inputText: `{ + "sFloat": 1.234, + "sDouble": 5.678 +}`, + wantMessage: &pbeditions.ImplicitScalars{ + SFloat: 1.234, + SDouble: 5.678, + }, + }, { + desc: "float and double in string", + inputMessage: &pbeditions.ImplicitScalars{}, + inputText: `{ + "sFloat": "1.234", + "sDouble": "5.678" +}`, + wantMessage: &pbeditions.ImplicitScalars{ + SFloat: 1.234, + SDouble: 5.678, + }, + }, { + desc: "float and double in E notation", + inputMessage: &pbeditions.ImplicitScalars{}, + inputText: `{ + "sFloat": 12.34E-1, + "sDouble": 5.678e4 +}`, + wantMessage: &pbeditions.ImplicitScalars{ + SFloat: 1.234, + SDouble: 56780, + }, + }, { + desc: "float and double in string E notation", + inputMessage: &pbeditions.ImplicitScalars{}, + inputText: `{ + "sFloat": "12.34E-1", + "sDouble": "5.678e4" +}`, + wantMessage: &pbeditions.ImplicitScalars{ + SFloat: 1.234, + SDouble: 56780, + }, }, { desc: "proto3 scalars set to null", inputMessage: &pb3.Scalars{}, @@ -2259,6 +2383,82 @@ func TestUnmarshal(t *testing.T) { } }`, wantErr: `(line 5:14): invalid UTF-8`, + }, { + desc: "well known types as field values in editions proto", + inputMessage: &pbeditions.KnownTypes{}, + inputText: `{ + "optBool": false, + "optInt32": 42, + "optInt64": "42", + "optUint32": 42, + "optUint64": "42", + "optFloat": 1.23, + "optDouble": 3.1415, + "optString": "hello", + "optBytes": "aGVsbG8=", + "optDuration": "123s", + "optTimestamp": "2019-03-19T23:03:21Z", + "optStruct": { + "string": "hello" + }, + "optList": [ + null, + "", + {}, + [] + ], + "optValue": "world", + "optEmpty": {}, + "optAny": { + "@type": "google.protobuf.Empty", + "value": {} + }, + "optFieldmask": "fooBar,barFoo" +}`, + wantMessage: &pbeditions.KnownTypes{ + OptBool: &wrapperspb.BoolValue{Value: false}, + OptInt32: &wrapperspb.Int32Value{Value: 42}, + OptInt64: &wrapperspb.Int64Value{Value: 42}, + OptUint32: &wrapperspb.UInt32Value{Value: 42}, + OptUint64: &wrapperspb.UInt64Value{Value: 42}, + OptFloat: &wrapperspb.FloatValue{Value: 1.23}, + OptDouble: &wrapperspb.DoubleValue{Value: 3.1415}, + OptString: &wrapperspb.StringValue{Value: "hello"}, + OptBytes: &wrapperspb.BytesValue{Value: []byte("hello")}, + OptDuration: &durationpb.Duration{Seconds: 123}, + OptTimestamp: ×tamppb.Timestamp{Seconds: 1553036601}, + OptStruct: &structpb.Struct{ + Fields: map[string]*structpb.Value{ + "string": {Kind: &structpb.Value_StringValue{"hello"}}, + }, + }, + OptList: &structpb.ListValue{ + Values: []*structpb.Value{ + {Kind: &structpb.Value_NullValue{}}, + {Kind: &structpb.Value_StringValue{}}, + { + Kind: &structpb.Value_StructValue{ + &structpb.Struct{Fields: map[string]*structpb.Value{}}, + }, + }, + { + Kind: &structpb.Value_ListValue{ + &structpb.ListValue{Values: []*structpb.Value{}}, + }, + }, + }, + }, + OptValue: &structpb.Value{ + Kind: &structpb.Value_StringValue{"world"}, + }, + OptEmpty: &emptypb.Empty{}, + OptAny: &anypb.Any{ + TypeUrl: "google.protobuf.Empty", + }, + OptFieldmask: &fieldmaskpb.FieldMask{ + Paths: []string{"foo_bar", "bar_foo"}, + }, + }, }, { desc: "well known types as field values", inputMessage: &pb2.KnownTypes{}, diff --git a/encoding/protojson/fuzz_test.go b/encoding/protojson/fuzz_test.go new file mode 100644 index 00000000..f53b36a2 --- /dev/null +++ b/encoding/protojson/fuzz_test.go @@ -0,0 +1,101 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Go native fuzzing was added in go1.18. Remove this once we stop supporting +// go1.17. +//go:build go1.18 + +package protojson_test + +import ( + "math" + "testing" + + "github.com/google/go-cmp/cmp" + "google.golang.org/protobuf/encoding/protojson" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/reflect/protoreflect" + "google.golang.org/protobuf/testing/protocmp" + + testfuzzpb "google.golang.org/protobuf/internal/testprotos/editionsfuzztest" +) + +// roundTripAndCompareProto tests if a protojson.Marshal/Unmarshal roundtrip +// preserves the contents of the message. Note: wireBytes are a protocol +// buffer wire format message, not the JSON formatted proto. We do this because +// a random stream of bytes (e.g. generated by the fuzz engine) is more likely +// to be valid proto wire format than that it is valid json format. +func roundTripAndCompareProto(t *testing.T, wireBytes []byte, messages ...proto.Message) { + for _, msg := range messages { + src := msg.ProtoReflect().Type().New().Interface() + + if err := proto.Unmarshal(wireBytes, src); err != nil { + // Ignoring invalid wire format since we want to test the protojson + // implementation, not the wireformat implementation. + return + } + + // Unknown fields are not marshaled by protojson so we strip them. + src.ProtoReflect().SetUnknown(nil) + var ranger func(protoreflect.FieldDescriptor, protoreflect.Value) bool + stripUnknown := func(m protoreflect.Message) { + m.SetUnknown(nil) + m.Range(ranger) + } + ranger = func(fd protoreflect.FieldDescriptor, v protoreflect.Value) bool { + switch { + case fd.IsMap(): + if fd.MapValue().Message() != nil { + v.Map().Range(func(_ protoreflect.MapKey, v protoreflect.Value) bool { + stripUnknown(v.Message()) + return true + }) + } + case fd.Message() != nil: + if fd.Cardinality() == protoreflect.Repeated { + l := v.List() + for i := 0; i < l.Len(); i++ { + stripUnknown(l.Get(i).Message()) + } + } else { + stripUnknown(v.Message()) + } + } + return true + } + stripUnknown(src.ProtoReflect()) + + jsonBytes, err := protojson.Marshal(src) + if err != nil { + t.Errorf("failed to marshal messsage to json: %v\nmessage: %v", err, src) + } + dst := msg.ProtoReflect().Type().New().Interface() + + if err := protojson.Unmarshal(jsonBytes, dst); err != nil { + t.Errorf("failed to unmarshal messsage from json: %v\njson: %s", err, jsonBytes) + } + + // The cmp package does not deal with NaN on its own and will report + // NaN != NaN. + optNaN64 := cmp.Comparer(func(x, y float32) bool { + return (math.IsNaN(float64(x)) && math.IsNaN(float64(y))) || x == y + }) + optNaN32 := cmp.Comparer(func(x, y float64) bool { + return (math.IsNaN(x) && math.IsNaN(y)) || x == y + }) + if diff := cmp.Diff(src, dst, protocmp.Transform(), optNaN64, optNaN32); diff != "" { + t.Error(diff) + } + } +} + +func FuzzEncodeDecodeRoundTrip(f *testing.F) { + f.Add([]byte("Hello World!")) + f.Fuzz(func(t *testing.T, in []byte) { + // We cannot test proto2 because it does not have UTF-8 validation + // but the JSON spec requires valid UTF-8 and thus we might initialize + // proto2 messages with invalid UTF-8 and then fail marshalling it. + roundTripAndCompareProto(t, in, (*testfuzzpb.TestAllTypesProto3)(nil), (*testfuzzpb.TestAllTypesProto3Editions)(nil)) + }) +} diff --git a/internal/testprotos/textpbeditions/test2.pb.go b/internal/testprotos/textpbeditions/test2.pb.go new file mode 100644 index 00000000..aae27ba2 --- /dev/null +++ b/internal/testprotos/textpbeditions/test2.pb.go @@ -0,0 +1,2795 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Test Protobuf definitions with proto2 syntax. + +// Code generated by protoc-gen-go. DO NOT EDIT. +// source: internal/testprotos/textpbeditions/test2.proto + +package textpbeditions + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + anypb "google.golang.org/protobuf/types/known/anypb" + durationpb "google.golang.org/protobuf/types/known/durationpb" + emptypb "google.golang.org/protobuf/types/known/emptypb" + fieldmaskpb "google.golang.org/protobuf/types/known/fieldmaskpb" + structpb "google.golang.org/protobuf/types/known/structpb" + timestamppb "google.golang.org/protobuf/types/known/timestamppb" + wrapperspb "google.golang.org/protobuf/types/known/wrapperspb" + reflect "reflect" + sync "sync" +) + +type Enum int32 + +const ( + Enum_ONE Enum = 1 + Enum_TWO Enum = 2 + Enum_TEN Enum = 10 +) + +// Enum value maps for Enum. +var ( + Enum_name = map[int32]string{ + 1: "ONE", + 2: "TWO", + 10: "TEN", + } + Enum_value = map[string]int32{ + "ONE": 1, + "TWO": 2, + "TEN": 10, + } +) + +func (x Enum) Enum() *Enum { + p := new(Enum) + *p = x + return p +} + +func (x Enum) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Enum) Descriptor() protoreflect.EnumDescriptor { + return file_internal_testprotos_textpbeditions_test2_proto_enumTypes[0].Descriptor() +} + +func (Enum) Type() protoreflect.EnumType { + return &file_internal_testprotos_textpbeditions_test2_proto_enumTypes[0] +} + +func (x Enum) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Enum.Descriptor instead. +func (Enum) EnumDescriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{0} +} + +type Enums_NestedEnum int32 + +const ( + Enums_UNO Enums_NestedEnum = 1 + Enums_DOS Enums_NestedEnum = 2 + Enums_DIEZ Enums_NestedEnum = 10 +) + +// Enum value maps for Enums_NestedEnum. +var ( + Enums_NestedEnum_name = map[int32]string{ + 1: "UNO", + 2: "DOS", + 10: "DIEZ", + } + Enums_NestedEnum_value = map[string]int32{ + "UNO": 1, + "DOS": 2, + "DIEZ": 10, + } +) + +func (x Enums_NestedEnum) Enum() *Enums_NestedEnum { + p := new(Enums_NestedEnum) + *p = x + return p +} + +func (x Enums_NestedEnum) String() string { + return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) +} + +func (Enums_NestedEnum) Descriptor() protoreflect.EnumDescriptor { + return file_internal_testprotos_textpbeditions_test2_proto_enumTypes[1].Descriptor() +} + +func (Enums_NestedEnum) Type() protoreflect.EnumType { + return &file_internal_testprotos_textpbeditions_test2_proto_enumTypes[1] +} + +func (x Enums_NestedEnum) Number() protoreflect.EnumNumber { + return protoreflect.EnumNumber(x) +} + +// Deprecated: Use Enums_NestedEnum.Descriptor instead. +func (Enums_NestedEnum) EnumDescriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{2, 0} +} + +// Scalars contains scalar fields. +type Scalars struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptBool *bool `protobuf:"varint,1,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"` + OptInt32 *int32 `protobuf:"varint,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"` + OptInt64 *int64 `protobuf:"varint,3,opt,name=opt_int64,json=optInt64" json:"opt_int64,omitempty"` + OptUint32 *uint32 `protobuf:"varint,4,opt,name=opt_uint32,json=optUint32" json:"opt_uint32,omitempty"` + OptUint64 *uint64 `protobuf:"varint,5,opt,name=opt_uint64,json=optUint64" json:"opt_uint64,omitempty"` + OptSint32 *int32 `protobuf:"zigzag32,6,opt,name=opt_sint32,json=optSint32" json:"opt_sint32,omitempty"` + OptSint64 *int64 `protobuf:"zigzag64,7,opt,name=opt_sint64,json=optSint64" json:"opt_sint64,omitempty"` + OptFixed32 *uint32 `protobuf:"fixed32,8,opt,name=opt_fixed32,json=optFixed32" json:"opt_fixed32,omitempty"` + OptFixed64 *uint64 `protobuf:"fixed64,9,opt,name=opt_fixed64,json=optFixed64" json:"opt_fixed64,omitempty"` + OptSfixed32 *int32 `protobuf:"fixed32,10,opt,name=opt_sfixed32,json=optSfixed32" json:"opt_sfixed32,omitempty"` + OptSfixed64 *int64 `protobuf:"fixed64,11,opt,name=opt_sfixed64,json=optSfixed64" json:"opt_sfixed64,omitempty"` + OptFloat *float32 `protobuf:"fixed32,20,opt,name=opt_float,json=optFloat" json:"opt_float,omitempty"` + OptDouble *float64 `protobuf:"fixed64,21,opt,name=opt_double,json=optDouble" json:"opt_double,omitempty"` + OptBytes []byte `protobuf:"bytes,14,opt,name=opt_bytes,json=optBytes" json:"opt_bytes,omitempty"` + OptString *string `protobuf:"bytes,13,opt,name=opt_string,json=optString" json:"opt_string,omitempty"` +} + +func (x *Scalars) Reset() { + *x = Scalars{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Scalars) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Scalars) ProtoMessage() {} + +func (x *Scalars) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Scalars.ProtoReflect.Descriptor instead. +func (*Scalars) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{0} +} + +func (x *Scalars) GetOptBool() bool { + if x != nil && x.OptBool != nil { + return *x.OptBool + } + return false +} + +func (x *Scalars) GetOptInt32() int32 { + if x != nil && x.OptInt32 != nil { + return *x.OptInt32 + } + return 0 +} + +func (x *Scalars) GetOptInt64() int64 { + if x != nil && x.OptInt64 != nil { + return *x.OptInt64 + } + return 0 +} + +func (x *Scalars) GetOptUint32() uint32 { + if x != nil && x.OptUint32 != nil { + return *x.OptUint32 + } + return 0 +} + +func (x *Scalars) GetOptUint64() uint64 { + if x != nil && x.OptUint64 != nil { + return *x.OptUint64 + } + return 0 +} + +func (x *Scalars) GetOptSint32() int32 { + if x != nil && x.OptSint32 != nil { + return *x.OptSint32 + } + return 0 +} + +func (x *Scalars) GetOptSint64() int64 { + if x != nil && x.OptSint64 != nil { + return *x.OptSint64 + } + return 0 +} + +func (x *Scalars) GetOptFixed32() uint32 { + if x != nil && x.OptFixed32 != nil { + return *x.OptFixed32 + } + return 0 +} + +func (x *Scalars) GetOptFixed64() uint64 { + if x != nil && x.OptFixed64 != nil { + return *x.OptFixed64 + } + return 0 +} + +func (x *Scalars) GetOptSfixed32() int32 { + if x != nil && x.OptSfixed32 != nil { + return *x.OptSfixed32 + } + return 0 +} + +func (x *Scalars) GetOptSfixed64() int64 { + if x != nil && x.OptSfixed64 != nil { + return *x.OptSfixed64 + } + return 0 +} + +func (x *Scalars) GetOptFloat() float32 { + if x != nil && x.OptFloat != nil { + return *x.OptFloat + } + return 0 +} + +func (x *Scalars) GetOptDouble() float64 { + if x != nil && x.OptDouble != nil { + return *x.OptDouble + } + return 0 +} + +func (x *Scalars) GetOptBytes() []byte { + if x != nil { + return x.OptBytes + } + return nil +} + +func (x *Scalars) GetOptString() string { + if x != nil && x.OptString != nil { + return *x.OptString + } + return "" +} + +// ImplicitScalars contains scalar field types with implicit field_presence +type ImplicitScalars struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + SBool bool `protobuf:"varint,1,opt,name=s_bool,json=sBool" json:"s_bool,omitempty"` + SInt32 int32 `protobuf:"varint,2,opt,name=s_int32,json=sInt32" json:"s_int32,omitempty"` + SInt64 int64 `protobuf:"varint,3,opt,name=s_int64,json=sInt64" json:"s_int64,omitempty"` + SUint32 uint32 `protobuf:"varint,4,opt,name=s_uint32,json=sUint32" json:"s_uint32,omitempty"` + SUint64 uint64 `protobuf:"varint,5,opt,name=s_uint64,json=sUint64" json:"s_uint64,omitempty"` + SSint32 int32 `protobuf:"zigzag32,6,opt,name=s_sint32,json=sSint32" json:"s_sint32,omitempty"` + SSint64 int64 `protobuf:"zigzag64,7,opt,name=s_sint64,json=sSint64" json:"s_sint64,omitempty"` + SFixed32 uint32 `protobuf:"fixed32,8,opt,name=s_fixed32,json=sFixed32" json:"s_fixed32,omitempty"` + SFixed64 uint64 `protobuf:"fixed64,9,opt,name=s_fixed64,json=sFixed64" json:"s_fixed64,omitempty"` + SSfixed32 int32 `protobuf:"fixed32,10,opt,name=s_sfixed32,json=sSfixed32" json:"s_sfixed32,omitempty"` + SSfixed64 int64 `protobuf:"fixed64,11,opt,name=s_sfixed64,json=sSfixed64" json:"s_sfixed64,omitempty"` + SFloat float32 `protobuf:"fixed32,20,opt,name=s_float,json=sFloat" json:"s_float,omitempty"` + SDouble float64 `protobuf:"fixed64,21,opt,name=s_double,json=sDouble" json:"s_double,omitempty"` + SBytes []byte `protobuf:"bytes,14,opt,name=s_bytes,json=sBytes" json:"s_bytes,omitempty"` + SString string `protobuf:"bytes,13,opt,name=s_string,json=sString" json:"s_string,omitempty"` +} + +func (x *ImplicitScalars) Reset() { + *x = ImplicitScalars{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ImplicitScalars) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ImplicitScalars) ProtoMessage() {} + +func (x *ImplicitScalars) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ImplicitScalars.ProtoReflect.Descriptor instead. +func (*ImplicitScalars) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{1} +} + +func (x *ImplicitScalars) GetSBool() bool { + if x != nil { + return x.SBool + } + return false +} + +func (x *ImplicitScalars) GetSInt32() int32 { + if x != nil { + return x.SInt32 + } + return 0 +} + +func (x *ImplicitScalars) GetSInt64() int64 { + if x != nil { + return x.SInt64 + } + return 0 +} + +func (x *ImplicitScalars) GetSUint32() uint32 { + if x != nil { + return x.SUint32 + } + return 0 +} + +func (x *ImplicitScalars) GetSUint64() uint64 { + if x != nil { + return x.SUint64 + } + return 0 +} + +func (x *ImplicitScalars) GetSSint32() int32 { + if x != nil { + return x.SSint32 + } + return 0 +} + +func (x *ImplicitScalars) GetSSint64() int64 { + if x != nil { + return x.SSint64 + } + return 0 +} + +func (x *ImplicitScalars) GetSFixed32() uint32 { + if x != nil { + return x.SFixed32 + } + return 0 +} + +func (x *ImplicitScalars) GetSFixed64() uint64 { + if x != nil { + return x.SFixed64 + } + return 0 +} + +func (x *ImplicitScalars) GetSSfixed32() int32 { + if x != nil { + return x.SSfixed32 + } + return 0 +} + +func (x *ImplicitScalars) GetSSfixed64() int64 { + if x != nil { + return x.SSfixed64 + } + return 0 +} + +func (x *ImplicitScalars) GetSFloat() float32 { + if x != nil { + return x.SFloat + } + return 0 +} + +func (x *ImplicitScalars) GetSDouble() float64 { + if x != nil { + return x.SDouble + } + return 0 +} + +func (x *ImplicitScalars) GetSBytes() []byte { + if x != nil { + return x.SBytes + } + return nil +} + +func (x *ImplicitScalars) GetSString() string { + if x != nil { + return x.SString + } + return "" +} + +// Message contains enum fields. +type Enums struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptEnum *Enum `protobuf:"varint,1,opt,name=opt_enum,json=optEnum,enum=pbeditions.Enum" json:"opt_enum,omitempty"` + RptEnum []Enum `protobuf:"varint,2,rep,packed,name=rpt_enum,json=rptEnum,enum=pbeditions.Enum" json:"rpt_enum,omitempty"` + OptNestedEnum *Enums_NestedEnum `protobuf:"varint,3,opt,name=opt_nested_enum,json=optNestedEnum,enum=pbeditions.Enums_NestedEnum" json:"opt_nested_enum,omitempty"` + RptNestedEnum []Enums_NestedEnum `protobuf:"varint,4,rep,packed,name=rpt_nested_enum,json=rptNestedEnum,enum=pbeditions.Enums_NestedEnum" json:"rpt_nested_enum,omitempty"` +} + +func (x *Enums) Reset() { + *x = Enums{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Enums) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Enums) ProtoMessage() {} + +func (x *Enums) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Enums.ProtoReflect.Descriptor instead. +func (*Enums) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{2} +} + +func (x *Enums) GetOptEnum() Enum { + if x != nil && x.OptEnum != nil { + return *x.OptEnum + } + return Enum_ONE +} + +func (x *Enums) GetRptEnum() []Enum { + if x != nil { + return x.RptEnum + } + return nil +} + +func (x *Enums) GetOptNestedEnum() Enums_NestedEnum { + if x != nil && x.OptNestedEnum != nil { + return *x.OptNestedEnum + } + return Enums_UNO +} + +func (x *Enums) GetRptNestedEnum() []Enums_NestedEnum { + if x != nil { + return x.RptNestedEnum + } + return nil +} + +// Message contains repeated fields. +type Repeats struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RptBool []bool `protobuf:"varint,1,rep,packed,name=rpt_bool,json=rptBool" json:"rpt_bool,omitempty"` + RptInt32 []int32 `protobuf:"varint,2,rep,packed,name=rpt_int32,json=rptInt32" json:"rpt_int32,omitempty"` + RptInt64 []int64 `protobuf:"varint,3,rep,packed,name=rpt_int64,json=rptInt64" json:"rpt_int64,omitempty"` + RptUint32 []uint32 `protobuf:"varint,4,rep,packed,name=rpt_uint32,json=rptUint32" json:"rpt_uint32,omitempty"` + RptUint64 []uint64 `protobuf:"varint,5,rep,packed,name=rpt_uint64,json=rptUint64" json:"rpt_uint64,omitempty"` + RptFloat []float32 `protobuf:"fixed32,6,rep,packed,name=rpt_float,json=rptFloat" json:"rpt_float,omitempty"` + RptDouble []float64 `protobuf:"fixed64,7,rep,packed,name=rpt_double,json=rptDouble" json:"rpt_double,omitempty"` + RptString []string `protobuf:"bytes,8,rep,name=rpt_string,json=rptString" json:"rpt_string,omitempty"` + RptBytes [][]byte `protobuf:"bytes,9,rep,name=rpt_bytes,json=rptBytes" json:"rpt_bytes,omitempty"` +} + +func (x *Repeats) Reset() { + *x = Repeats{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Repeats) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Repeats) ProtoMessage() {} + +func (x *Repeats) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Repeats.ProtoReflect.Descriptor instead. +func (*Repeats) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{3} +} + +func (x *Repeats) GetRptBool() []bool { + if x != nil { + return x.RptBool + } + return nil +} + +func (x *Repeats) GetRptInt32() []int32 { + if x != nil { + return x.RptInt32 + } + return nil +} + +func (x *Repeats) GetRptInt64() []int64 { + if x != nil { + return x.RptInt64 + } + return nil +} + +func (x *Repeats) GetRptUint32() []uint32 { + if x != nil { + return x.RptUint32 + } + return nil +} + +func (x *Repeats) GetRptUint64() []uint64 { + if x != nil { + return x.RptUint64 + } + return nil +} + +func (x *Repeats) GetRptFloat() []float32 { + if x != nil { + return x.RptFloat + } + return nil +} + +func (x *Repeats) GetRptDouble() []float64 { + if x != nil { + return x.RptDouble + } + return nil +} + +func (x *Repeats) GetRptString() []string { + if x != nil { + return x.RptString + } + return nil +} + +func (x *Repeats) GetRptBytes() [][]byte { + if x != nil { + return x.RptBytes + } + return nil +} + +// Message contains map fields. +type Maps struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Int32ToStr map[int32]string `protobuf:"bytes,1,rep,name=int32_to_str,json=int32ToStr" json:"int32_to_str,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + StrToNested map[string]*Nested `protobuf:"bytes,4,rep,name=str_to_nested,json=strToNested" json:"str_to_nested,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` +} + +func (x *Maps) Reset() { + *x = Maps{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Maps) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Maps) ProtoMessage() {} + +func (x *Maps) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Maps.ProtoReflect.Descriptor instead. +func (*Maps) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{4} +} + +func (x *Maps) GetInt32ToStr() map[int32]string { + if x != nil { + return x.Int32ToStr + } + return nil +} + +func (x *Maps) GetStrToNested() map[string]*Nested { + if x != nil { + return x.StrToNested + } + return nil +} + +// Message type used as submessage. +type Nested struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"` + OptNested *Nested `protobuf:"bytes,2,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"` +} + +func (x *Nested) Reset() { + *x = Nested{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nested) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nested) ProtoMessage() {} + +func (x *Nested) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Nested.ProtoReflect.Descriptor instead. +func (*Nested) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{5} +} + +func (x *Nested) GetOptString() string { + if x != nil && x.OptString != nil { + return *x.OptString + } + return "" +} + +func (x *Nested) GetOptNested() *Nested { + if x != nil { + return x.OptNested + } + return nil +} + +// Message contains message and group fields. +type Nests struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptNested *Nested `protobuf:"bytes,1,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"` + Optgroup *Nests_OptGroup `protobuf:"group,2,opt,name=OptGroup,json=optgroup" json:"optgroup,omitempty"` + RptNested []*Nested `protobuf:"bytes,4,rep,name=rpt_nested,json=rptNested" json:"rpt_nested,omitempty"` + Rptgroup []*Nests_RptGroup `protobuf:"group,5,rep,name=RptGroup,json=rptgroup" json:"rptgroup,omitempty"` +} + +func (x *Nests) Reset() { + *x = Nests{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nests) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nests) ProtoMessage() {} + +func (x *Nests) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Nests.ProtoReflect.Descriptor instead. +func (*Nests) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{6} +} + +func (x *Nests) GetOptNested() *Nested { + if x != nil { + return x.OptNested + } + return nil +} + +func (x *Nests) GetOptgroup() *Nests_OptGroup { + if x != nil { + return x.Optgroup + } + return nil +} + +func (x *Nests) GetRptNested() []*Nested { + if x != nil { + return x.RptNested + } + return nil +} + +func (x *Nests) GetRptgroup() []*Nests_RptGroup { + if x != nil { + return x.Rptgroup + } + return nil +} + +// Message contains required fields. +type Requireds struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ReqBool *bool `protobuf:"varint,1,req,name=req_bool,json=reqBool" json:"req_bool,omitempty"` + ReqSfixed64 *int64 `protobuf:"fixed64,2,req,name=req_sfixed64,json=reqSfixed64" json:"req_sfixed64,omitempty"` + ReqDouble *float64 `protobuf:"fixed64,3,req,name=req_double,json=reqDouble" json:"req_double,omitempty"` + ReqString *string `protobuf:"bytes,4,req,name=req_string,json=reqString" json:"req_string,omitempty"` + ReqEnum *Enum `protobuf:"varint,5,req,name=req_enum,json=reqEnum,enum=pbeditions.Enum" json:"req_enum,omitempty"` + ReqNested *Nested `protobuf:"bytes,6,req,name=req_nested,json=reqNested" json:"req_nested,omitempty"` +} + +func (x *Requireds) Reset() { + *x = Requireds{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Requireds) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Requireds) ProtoMessage() {} + +func (x *Requireds) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Requireds.ProtoReflect.Descriptor instead. +func (*Requireds) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{7} +} + +func (x *Requireds) GetReqBool() bool { + if x != nil && x.ReqBool != nil { + return *x.ReqBool + } + return false +} + +func (x *Requireds) GetReqSfixed64() int64 { + if x != nil && x.ReqSfixed64 != nil { + return *x.ReqSfixed64 + } + return 0 +} + +func (x *Requireds) GetReqDouble() float64 { + if x != nil && x.ReqDouble != nil { + return *x.ReqDouble + } + return 0 +} + +func (x *Requireds) GetReqString() string { + if x != nil && x.ReqString != nil { + return *x.ReqString + } + return "" +} + +func (x *Requireds) GetReqEnum() Enum { + if x != nil && x.ReqEnum != nil { + return *x.ReqEnum + } + return Enum_ONE +} + +func (x *Requireds) GetReqNested() *Nested { + if x != nil { + return x.ReqNested + } + return nil +} + +// Message contains both required and optional fields. +type PartialRequired struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ReqString *string `protobuf:"bytes,1,req,name=req_string,json=reqString" json:"req_string,omitempty"` + OptString *string `protobuf:"bytes,2,opt,name=opt_string,json=optString" json:"opt_string,omitempty"` +} + +func (x *PartialRequired) Reset() { + *x = PartialRequired{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PartialRequired) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PartialRequired) ProtoMessage() {} + +func (x *PartialRequired) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PartialRequired.ProtoReflect.Descriptor instead. +func (*PartialRequired) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{8} +} + +func (x *PartialRequired) GetReqString() string { + if x != nil && x.ReqString != nil { + return *x.ReqString + } + return "" +} + +func (x *PartialRequired) GetOptString() string { + if x != nil && x.OptString != nil { + return *x.OptString + } + return "" +} + +type NestedWithRequired struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ReqString *string `protobuf:"bytes,1,req,name=req_string,json=reqString" json:"req_string,omitempty"` +} + +func (x *NestedWithRequired) Reset() { + *x = NestedWithRequired{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *NestedWithRequired) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*NestedWithRequired) ProtoMessage() {} + +func (x *NestedWithRequired) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use NestedWithRequired.ProtoReflect.Descriptor instead. +func (*NestedWithRequired) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{9} +} + +func (x *NestedWithRequired) GetReqString() string { + if x != nil && x.ReqString != nil { + return *x.ReqString + } + return "" +} + +type IndirectRequired struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptNested *NestedWithRequired `protobuf:"bytes,1,req,name=opt_nested,json=optNested" json:"opt_nested,omitempty"` + RptNested []*NestedWithRequired `protobuf:"bytes,2,rep,name=rpt_nested,json=rptNested" json:"rpt_nested,omitempty"` + StrToNested map[string]*NestedWithRequired `protobuf:"bytes,3,rep,name=str_to_nested,json=strToNested" json:"str_to_nested,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"` + // Types that are assignable to Union: + // + // *IndirectRequired_OneofNested + Union isIndirectRequired_Union `protobuf_oneof:"union"` +} + +func (x *IndirectRequired) Reset() { + *x = IndirectRequired{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *IndirectRequired) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IndirectRequired) ProtoMessage() {} + +func (x *IndirectRequired) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use IndirectRequired.ProtoReflect.Descriptor instead. +func (*IndirectRequired) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{10} +} + +func (x *IndirectRequired) GetOptNested() *NestedWithRequired { + if x != nil { + return x.OptNested + } + return nil +} + +func (x *IndirectRequired) GetRptNested() []*NestedWithRequired { + if x != nil { + return x.RptNested + } + return nil +} + +func (x *IndirectRequired) GetStrToNested() map[string]*NestedWithRequired { + if x != nil { + return x.StrToNested + } + return nil +} + +func (m *IndirectRequired) GetUnion() isIndirectRequired_Union { + if m != nil { + return m.Union + } + return nil +} + +func (x *IndirectRequired) GetOneofNested() *NestedWithRequired { + if x, ok := x.GetUnion().(*IndirectRequired_OneofNested); ok { + return x.OneofNested + } + return nil +} + +type isIndirectRequired_Union interface { + isIndirectRequired_Union() +} + +type IndirectRequired_OneofNested struct { + OneofNested *NestedWithRequired `protobuf:"bytes,4,opt,name=oneof_nested,json=oneofNested,oneof"` +} + +func (*IndirectRequired_OneofNested) isIndirectRequired_Union() {} + +type Extensions struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields + + OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"` + OptBool *bool `protobuf:"varint,101,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"` + OptInt32 *int32 `protobuf:"varint,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"` +} + +func (x *Extensions) Reset() { + *x = Extensions{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Extensions) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Extensions) ProtoMessage() {} + +func (x *Extensions) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Extensions.ProtoReflect.Descriptor instead. +func (*Extensions) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{11} +} + +func (x *Extensions) GetOptString() string { + if x != nil && x.OptString != nil { + return *x.OptString + } + return "" +} + +func (x *Extensions) GetOptBool() bool { + if x != nil && x.OptBool != nil { + return *x.OptBool + } + return false +} + +func (x *Extensions) GetOptInt32() int32 { + if x != nil && x.OptInt32 != nil { + return *x.OptInt32 + } + return 0 +} + +type ExtensionsContainer struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields +} + +func (x *ExtensionsContainer) Reset() { + *x = ExtensionsContainer{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *ExtensionsContainer) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ExtensionsContainer) ProtoMessage() {} + +func (x *ExtensionsContainer) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ExtensionsContainer.ProtoReflect.Descriptor instead. +func (*ExtensionsContainer) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{12} +} + +type MessageSet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields +} + +func (x *MessageSet) Reset() { + *x = MessageSet{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MessageSet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MessageSet) ProtoMessage() {} + +func (x *MessageSet) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MessageSet.ProtoReflect.Descriptor instead. +func (*MessageSet) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{13} +} + +type MessageSetExtension struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"` +} + +func (x *MessageSetExtension) Reset() { + *x = MessageSetExtension{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *MessageSetExtension) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*MessageSetExtension) ProtoMessage() {} + +func (x *MessageSetExtension) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use MessageSetExtension.ProtoReflect.Descriptor instead. +func (*MessageSetExtension) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{14} +} + +func (x *MessageSetExtension) GetOptString() string { + if x != nil && x.OptString != nil { + return *x.OptString + } + return "" +} + +type FakeMessageSet struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + extensionFields protoimpl.ExtensionFields +} + +func (x *FakeMessageSet) Reset() { + *x = FakeMessageSet{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FakeMessageSet) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FakeMessageSet) ProtoMessage() {} + +func (x *FakeMessageSet) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FakeMessageSet.ProtoReflect.Descriptor instead. +func (*FakeMessageSet) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{15} +} + +type FakeMessageSetExtension struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"` +} + +func (x *FakeMessageSetExtension) Reset() { + *x = FakeMessageSetExtension{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *FakeMessageSetExtension) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FakeMessageSetExtension) ProtoMessage() {} + +func (x *FakeMessageSetExtension) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FakeMessageSetExtension.ProtoReflect.Descriptor instead. +func (*FakeMessageSetExtension) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{16} +} + +func (x *FakeMessageSetExtension) GetOptString() string { + if x != nil && x.OptString != nil { + return *x.OptString + } + return "" +} + +// Message contains well-known type fields. +type KnownTypes struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptBool *wrapperspb.BoolValue `protobuf:"bytes,1,opt,name=opt_bool,json=optBool" json:"opt_bool,omitempty"` + OptInt32 *wrapperspb.Int32Value `protobuf:"bytes,2,opt,name=opt_int32,json=optInt32" json:"opt_int32,omitempty"` + OptInt64 *wrapperspb.Int64Value `protobuf:"bytes,3,opt,name=opt_int64,json=optInt64" json:"opt_int64,omitempty"` + OptUint32 *wrapperspb.UInt32Value `protobuf:"bytes,4,opt,name=opt_uint32,json=optUint32" json:"opt_uint32,omitempty"` + OptUint64 *wrapperspb.UInt64Value `protobuf:"bytes,5,opt,name=opt_uint64,json=optUint64" json:"opt_uint64,omitempty"` + OptFloat *wrapperspb.FloatValue `protobuf:"bytes,6,opt,name=opt_float,json=optFloat" json:"opt_float,omitempty"` + OptDouble *wrapperspb.DoubleValue `protobuf:"bytes,7,opt,name=opt_double,json=optDouble" json:"opt_double,omitempty"` + OptString *wrapperspb.StringValue `protobuf:"bytes,8,opt,name=opt_string,json=optString" json:"opt_string,omitempty"` + OptBytes *wrapperspb.BytesValue `protobuf:"bytes,9,opt,name=opt_bytes,json=optBytes" json:"opt_bytes,omitempty"` + OptDuration *durationpb.Duration `protobuf:"bytes,20,opt,name=opt_duration,json=optDuration" json:"opt_duration,omitempty"` + OptTimestamp *timestamppb.Timestamp `protobuf:"bytes,21,opt,name=opt_timestamp,json=optTimestamp" json:"opt_timestamp,omitempty"` + OptStruct *structpb.Struct `protobuf:"bytes,25,opt,name=opt_struct,json=optStruct" json:"opt_struct,omitempty"` + OptList *structpb.ListValue `protobuf:"bytes,26,opt,name=opt_list,json=optList" json:"opt_list,omitempty"` + OptValue *structpb.Value `protobuf:"bytes,27,opt,name=opt_value,json=optValue" json:"opt_value,omitempty"` + OptNull *structpb.NullValue `protobuf:"varint,28,opt,name=opt_null,json=optNull,enum=google.protobuf.NullValue" json:"opt_null,omitempty"` + OptEmpty *emptypb.Empty `protobuf:"bytes,30,opt,name=opt_empty,json=optEmpty" json:"opt_empty,omitempty"` + OptAny *anypb.Any `protobuf:"bytes,32,opt,name=opt_any,json=optAny" json:"opt_any,omitempty"` + OptFieldmask *fieldmaskpb.FieldMask `protobuf:"bytes,40,opt,name=opt_fieldmask,json=optFieldmask" json:"opt_fieldmask,omitempty"` +} + +func (x *KnownTypes) Reset() { + *x = KnownTypes{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *KnownTypes) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*KnownTypes) ProtoMessage() {} + +func (x *KnownTypes) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use KnownTypes.ProtoReflect.Descriptor instead. +func (*KnownTypes) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{17} +} + +func (x *KnownTypes) GetOptBool() *wrapperspb.BoolValue { + if x != nil { + return x.OptBool + } + return nil +} + +func (x *KnownTypes) GetOptInt32() *wrapperspb.Int32Value { + if x != nil { + return x.OptInt32 + } + return nil +} + +func (x *KnownTypes) GetOptInt64() *wrapperspb.Int64Value { + if x != nil { + return x.OptInt64 + } + return nil +} + +func (x *KnownTypes) GetOptUint32() *wrapperspb.UInt32Value { + if x != nil { + return x.OptUint32 + } + return nil +} + +func (x *KnownTypes) GetOptUint64() *wrapperspb.UInt64Value { + if x != nil { + return x.OptUint64 + } + return nil +} + +func (x *KnownTypes) GetOptFloat() *wrapperspb.FloatValue { + if x != nil { + return x.OptFloat + } + return nil +} + +func (x *KnownTypes) GetOptDouble() *wrapperspb.DoubleValue { + if x != nil { + return x.OptDouble + } + return nil +} + +func (x *KnownTypes) GetOptString() *wrapperspb.StringValue { + if x != nil { + return x.OptString + } + return nil +} + +func (x *KnownTypes) GetOptBytes() *wrapperspb.BytesValue { + if x != nil { + return x.OptBytes + } + return nil +} + +func (x *KnownTypes) GetOptDuration() *durationpb.Duration { + if x != nil { + return x.OptDuration + } + return nil +} + +func (x *KnownTypes) GetOptTimestamp() *timestamppb.Timestamp { + if x != nil { + return x.OptTimestamp + } + return nil +} + +func (x *KnownTypes) GetOptStruct() *structpb.Struct { + if x != nil { + return x.OptStruct + } + return nil +} + +func (x *KnownTypes) GetOptList() *structpb.ListValue { + if x != nil { + return x.OptList + } + return nil +} + +func (x *KnownTypes) GetOptValue() *structpb.Value { + if x != nil { + return x.OptValue + } + return nil +} + +func (x *KnownTypes) GetOptNull() structpb.NullValue { + if x != nil && x.OptNull != nil { + return *x.OptNull + } + return structpb.NullValue(0) +} + +func (x *KnownTypes) GetOptEmpty() *emptypb.Empty { + if x != nil { + return x.OptEmpty + } + return nil +} + +func (x *KnownTypes) GetOptAny() *anypb.Any { + if x != nil { + return x.OptAny + } + return nil +} + +func (x *KnownTypes) GetOptFieldmask() *fieldmaskpb.FieldMask { + if x != nil { + return x.OptFieldmask + } + return nil +} + +type Nests_OptGroup struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptString *string `protobuf:"bytes,1,opt,name=opt_string,json=optString" json:"opt_string,omitempty"` + OptNested *Nested `protobuf:"bytes,2,opt,name=opt_nested,json=optNested" json:"opt_nested,omitempty"` + Optnestedgroup *Nests_OptGroup_OptNestedGroup `protobuf:"group,3,opt,name=OptNestedGroup,json=optnestedgroup" json:"optnestedgroup,omitempty"` +} + +func (x *Nests_OptGroup) Reset() { + *x = Nests_OptGroup{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nests_OptGroup) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nests_OptGroup) ProtoMessage() {} + +func (x *Nests_OptGroup) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Nests_OptGroup.ProtoReflect.Descriptor instead. +func (*Nests_OptGroup) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{6, 0} +} + +func (x *Nests_OptGroup) GetOptString() string { + if x != nil && x.OptString != nil { + return *x.OptString + } + return "" +} + +func (x *Nests_OptGroup) GetOptNested() *Nested { + if x != nil { + return x.OptNested + } + return nil +} + +func (x *Nests_OptGroup) GetOptnestedgroup() *Nests_OptGroup_OptNestedGroup { + if x != nil { + return x.Optnestedgroup + } + return nil +} + +type Nests_RptGroup struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + RptString []string `protobuf:"bytes,1,rep,name=rpt_string,json=rptString" json:"rpt_string,omitempty"` +} + +func (x *Nests_RptGroup) Reset() { + *x = Nests_RptGroup{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nests_RptGroup) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nests_RptGroup) ProtoMessage() {} + +func (x *Nests_RptGroup) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Nests_RptGroup.ProtoReflect.Descriptor instead. +func (*Nests_RptGroup) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{6, 1} +} + +func (x *Nests_RptGroup) GetRptString() []string { + if x != nil { + return x.RptString + } + return nil +} + +type Nests_OptGroup_OptNestedGroup struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + OptFixed32 *uint32 `protobuf:"fixed32,1,opt,name=opt_fixed32,json=optFixed32" json:"opt_fixed32,omitempty"` +} + +func (x *Nests_OptGroup_OptNestedGroup) Reset() { + *x = Nests_OptGroup_OptNestedGroup{} + if protoimpl.UnsafeEnabled { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Nests_OptGroup_OptNestedGroup) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Nests_OptGroup_OptNestedGroup) ProtoMessage() {} + +func (x *Nests_OptGroup_OptNestedGroup) ProtoReflect() protoreflect.Message { + mi := &file_internal_testprotos_textpbeditions_test2_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Nests_OptGroup_OptNestedGroup.ProtoReflect.Descriptor instead. +func (*Nests_OptGroup_OptNestedGroup) Descriptor() ([]byte, []int) { + return file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP(), []int{6, 0, 0} +} + +func (x *Nests_OptGroup_OptNestedGroup) GetOptFixed32() uint32 { + if x != nil && x.OptFixed32 != nil { + return *x.OptFixed32 + } + return 0 +} + +var file_internal_testprotos_textpbeditions_test2_proto_extTypes = []protoimpl.ExtensionInfo{ + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*bool)(nil), + Field: 21, + Name: "pbeditions.opt_ext_bool", + Tag: "varint,21,opt,name=opt_ext_bool", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*string)(nil), + Field: 22, + Name: "pbeditions.opt_ext_string", + Tag: "bytes,22,opt,name=opt_ext_string", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*Enum)(nil), + Field: 23, + Name: "pbeditions.opt_ext_enum", + Tag: "varint,23,opt,name=opt_ext_enum,enum=pbeditions.Enum", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*Nested)(nil), + Field: 24, + Name: "pbeditions.opt_ext_nested", + Tag: "bytes,24,opt,name=opt_ext_nested", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*PartialRequired)(nil), + Field: 25, + Name: "pbeditions.opt_ext_partial", + Tag: "bytes,25,opt,name=opt_ext_partial", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: ([]uint32)(nil), + Field: 31, + Name: "pbeditions.rpt_ext_fixed32", + Tag: "fixed32,31,rep,name=rpt_ext_fixed32", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: ([]Enum)(nil), + Field: 32, + Name: "pbeditions.rpt_ext_enum", + Tag: "varint,32,rep,name=rpt_ext_enum,enum=pbeditions.Enum", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: ([]*Nested)(nil), + Field: 33, + Name: "pbeditions.rpt_ext_nested", + Tag: "bytes,33,rep,name=rpt_ext_nested", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*MessageSet)(nil), + ExtensionType: (*FakeMessageSetExtension)(nil), + Field: 50, + Name: "pbeditions.message_set_extension", + Tag: "bytes,50,opt,name=message_set_extension", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*bool)(nil), + Field: 51, + Name: "pbeditions.ExtensionsContainer.opt_ext_bool", + Tag: "varint,51,opt,name=opt_ext_bool", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*string)(nil), + Field: 52, + Name: "pbeditions.ExtensionsContainer.opt_ext_string", + Tag: "bytes,52,opt,name=opt_ext_string", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*Enum)(nil), + Field: 53, + Name: "pbeditions.ExtensionsContainer.opt_ext_enum", + Tag: "varint,53,opt,name=opt_ext_enum,enum=pbeditions.Enum", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*Nested)(nil), + Field: 54, + Name: "pbeditions.ExtensionsContainer.opt_ext_nested", + Tag: "bytes,54,opt,name=opt_ext_nested", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: (*PartialRequired)(nil), + Field: 55, + Name: "pbeditions.ExtensionsContainer.opt_ext_partial", + Tag: "bytes,55,opt,name=opt_ext_partial", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: ([]string)(nil), + Field: 61, + Name: "pbeditions.ExtensionsContainer.rpt_ext_string", + Tag: "bytes,61,rep,name=rpt_ext_string", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: ([]Enum)(nil), + Field: 62, + Name: "pbeditions.ExtensionsContainer.rpt_ext_enum", + Tag: "varint,62,rep,name=rpt_ext_enum,enum=pbeditions.Enum", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*Extensions)(nil), + ExtensionType: ([]*Nested)(nil), + Field: 63, + Name: "pbeditions.ExtensionsContainer.rpt_ext_nested", + Tag: "bytes,63,rep,name=rpt_ext_nested", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*MessageSet)(nil), + ExtensionType: (*MessageSetExtension)(nil), + Field: 10, + Name: "pbeditions.MessageSetExtension.message_set_extension", + Tag: "bytes,10,opt,name=message_set_extension", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*MessageSet)(nil), + ExtensionType: (*MessageSetExtension)(nil), + Field: 20, + Name: "pbeditions.MessageSetExtension.not_message_set_extension", + Tag: "bytes,20,opt,name=not_message_set_extension", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*MessageSet)(nil), + ExtensionType: (*Nested)(nil), + Field: 30, + Name: "pbeditions.MessageSetExtension.ext_nested", + Tag: "bytes,30,opt,name=ext_nested", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, + { + ExtendedType: (*FakeMessageSet)(nil), + ExtensionType: (*FakeMessageSetExtension)(nil), + Field: 10, + Name: "pbeditions.FakeMessageSetExtension.message_set_extension", + Tag: "bytes,10,opt,name=message_set_extension", + Filename: "internal/testprotos/textpbeditions/test2.proto", + }, +} + +// Extension fields to Extensions. +var ( + // optional bool opt_ext_bool = 21; + E_OptExtBool = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[0] + // optional string opt_ext_string = 22; + E_OptExtString = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[1] + // optional pbeditions.Enum opt_ext_enum = 23; + E_OptExtEnum = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[2] + // optional pbeditions.Nested opt_ext_nested = 24; + E_OptExtNested = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[3] + // optional pbeditions.PartialRequired opt_ext_partial = 25; + E_OptExtPartial = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[4] + // repeated fixed32 rpt_ext_fixed32 = 31; + E_RptExtFixed32 = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[5] + // repeated pbeditions.Enum rpt_ext_enum = 32; + E_RptExtEnum = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[6] + // repeated pbeditions.Nested rpt_ext_nested = 33; + E_RptExtNested = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[7] + // optional bool opt_ext_bool = 51; + E_ExtensionsContainer_OptExtBool = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[9] + // optional string opt_ext_string = 52; + E_ExtensionsContainer_OptExtString = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[10] + // optional pbeditions.Enum opt_ext_enum = 53; + E_ExtensionsContainer_OptExtEnum = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[11] + // optional pbeditions.Nested opt_ext_nested = 54; + E_ExtensionsContainer_OptExtNested = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[12] + // optional pbeditions.PartialRequired opt_ext_partial = 55; + E_ExtensionsContainer_OptExtPartial = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[13] + // repeated string rpt_ext_string = 61; + E_ExtensionsContainer_RptExtString = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[14] + // repeated pbeditions.Enum rpt_ext_enum = 62; + E_ExtensionsContainer_RptExtEnum = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[15] + // repeated pbeditions.Nested rpt_ext_nested = 63; + E_ExtensionsContainer_RptExtNested = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[16] +) + +// Extension fields to MessageSet. +var ( + // optional pbeditions.FakeMessageSetExtension message_set_extension = 50; + E_MessageSetExtension = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[8] + // optional pbeditions.MessageSetExtension message_set_extension = 10; + E_MessageSetExtension_MessageSetExtension = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[17] + // optional pbeditions.MessageSetExtension not_message_set_extension = 20; + E_MessageSetExtension_NotMessageSetExtension = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[18] + // optional pbeditions.Nested ext_nested = 30; + E_MessageSetExtension_ExtNested = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[19] +) + +// Extension fields to FakeMessageSet. +var ( + // optional pbeditions.FakeMessageSetExtension message_set_extension = 10; + E_FakeMessageSetExtension_MessageSetExtension = &file_internal_testprotos_textpbeditions_test2_proto_extTypes[20] +) + +var File_internal_testprotos_textpbeditions_test2_proto protoreflect.FileDescriptor + +var file_internal_testprotos_textpbeditions_test2_proto_rawDesc = []byte{ + 0x0a, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2f, 0x74, 0x65, 0x73, 0x74, 0x32, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x12, 0x0a, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x1a, 0x19, 0x67, 0x6f, + 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x61, 0x6e, + 0x79, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1b, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x20, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6d, 0x61, 0x73, 0x6b, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1c, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1f, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x1a, 0x1e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2f, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2f, 0x77, 0x72, 0x61, 0x70, 0x70, 0x65, 0x72, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x22, 0xda, 0x03, 0x0a, 0x07, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x72, + 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1b, 0x0a, 0x09, + 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, + 0x08, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x70, 0x74, + 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x08, 0x6f, 0x70, + 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x75, 0x69, + 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x55, + 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, + 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x55, 0x69, + 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x69, 0x6e, 0x74, + 0x33, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x11, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x69, 0x6e, + 0x74, 0x33, 0x32, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x69, 0x6e, 0x74, 0x36, + 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x12, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x69, 0x6e, 0x74, + 0x36, 0x34, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, + 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x46, 0x69, 0x78, 0x65, + 0x64, 0x33, 0x32, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, + 0x36, 0x34, 0x18, 0x09, 0x20, 0x01, 0x28, 0x06, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x46, 0x69, 0x78, + 0x65, 0x64, 0x36, 0x34, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x66, 0x69, 0x78, + 0x65, 0x64, 0x33, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0f, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x53, + 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x21, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x73, + 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x10, 0x52, 0x0b, 0x6f, + 0x70, 0x74, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x70, + 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x02, 0x52, 0x08, 0x6f, + 0x70, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x64, + 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x15, 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x6f, 0x70, 0x74, + 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x79, + 0x74, 0x65, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x42, 0x79, + 0x74, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x22, 0x8f, 0x04, 0x0a, 0x0f, 0x49, 0x6d, 0x70, 0x6c, 0x69, 0x63, 0x69, 0x74, 0x53, + 0x63, 0x61, 0x6c, 0x61, 0x72, 0x73, 0x12, 0x1c, 0x0a, 0x06, 0x73, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x05, 0x73, + 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1e, 0x0a, 0x07, 0x73, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x05, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x06, 0x73, 0x49, + 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1e, 0x0a, 0x07, 0x73, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x03, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x06, 0x73, 0x49, + 0x6e, 0x74, 0x36, 0x34, 0x12, 0x20, 0x0a, 0x08, 0x73, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x0d, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x07, 0x73, + 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x20, 0x0a, 0x08, 0x73, 0x5f, 0x75, 0x69, 0x6e, 0x74, + 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x04, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, + 0x07, 0x73, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x20, 0x0a, 0x08, 0x73, 0x5f, 0x73, 0x69, + 0x6e, 0x74, 0x33, 0x32, 0x18, 0x06, 0x20, 0x01, 0x28, 0x11, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, + 0x02, 0x52, 0x07, 0x73, 0x53, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x20, 0x0a, 0x08, 0x73, 0x5f, + 0x73, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x07, 0x20, 0x01, 0x28, 0x12, 0x42, 0x05, 0xaa, 0x01, + 0x02, 0x08, 0x02, 0x52, 0x07, 0x73, 0x53, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x22, 0x0a, 0x09, + 0x73, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x18, 0x08, 0x20, 0x01, 0x28, 0x07, 0x42, + 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x08, 0x73, 0x46, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, + 0x12, 0x22, 0x0a, 0x09, 0x73, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x06, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x08, 0x73, 0x46, 0x69, 0x78, + 0x65, 0x64, 0x36, 0x34, 0x12, 0x24, 0x0a, 0x0a, 0x73, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, + 0x33, 0x32, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0f, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, + 0x09, 0x73, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x24, 0x0a, 0x0a, 0x73, 0x5f, + 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x10, 0x42, 0x05, + 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x09, 0x73, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, + 0x12, 0x1e, 0x0a, 0x07, 0x73, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, + 0x02, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x06, 0x73, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x12, 0x20, 0x0a, 0x08, 0x73, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x15, 0x20, 0x01, + 0x28, 0x01, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x07, 0x73, 0x44, 0x6f, 0x75, 0x62, + 0x6c, 0x65, 0x12, 0x1e, 0x0a, 0x07, 0x73, 0x5f, 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x0e, 0x20, + 0x01, 0x28, 0x0c, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x06, 0x73, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x12, 0x20, 0x0a, 0x08, 0x73, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x0d, + 0x20, 0x01, 0x28, 0x09, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x02, 0x52, 0x07, 0x73, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x22, 0x97, 0x02, 0x0a, 0x05, 0x45, 0x6e, 0x75, 0x6d, 0x73, 0x12, 0x2b, + 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x10, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x6e, + 0x75, 0x6d, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x2b, 0x0a, 0x08, 0x72, + 0x70, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x10, 0x2e, + 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, + 0x07, 0x72, 0x70, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x44, 0x0a, 0x0f, 0x6f, 0x70, 0x74, 0x5f, + 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x1c, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, + 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, + 0x0d, 0x6f, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x44, + 0x0a, 0x0f, 0x72, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x65, 0x6e, 0x75, + 0x6d, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0d, 0x72, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x45, 0x6e, 0x75, 0x6d, 0x22, 0x28, 0x0a, 0x0a, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, + 0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x55, 0x4e, 0x4f, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x44, + 0x4f, 0x53, 0x10, 0x02, 0x12, 0x08, 0x0a, 0x04, 0x44, 0x49, 0x45, 0x5a, 0x10, 0x0a, 0x22, 0x94, + 0x02, 0x0a, 0x07, 0x52, 0x65, 0x70, 0x65, 0x61, 0x74, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x70, + 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x03, 0x28, 0x08, 0x52, 0x07, 0x72, 0x70, + 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, + 0x33, 0x32, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x72, 0x70, 0x74, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x08, 0x72, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, + 0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, + 0x03, 0x28, 0x0d, 0x52, 0x09, 0x72, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x1d, + 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x03, + 0x28, 0x04, 0x52, 0x09, 0x72, 0x70, 0x74, 0x55, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x1b, 0x0a, + 0x09, 0x72, 0x70, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, 0x18, 0x06, 0x20, 0x03, 0x28, 0x02, + 0x52, 0x08, 0x72, 0x70, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70, + 0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x03, 0x28, 0x01, 0x52, 0x09, + 0x72, 0x70, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x74, + 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x08, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x72, + 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1b, 0x0a, 0x09, 0x72, 0x70, 0x74, 0x5f, + 0x62, 0x79, 0x74, 0x65, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x08, 0x72, 0x70, 0x74, + 0x42, 0x79, 0x74, 0x65, 0x73, 0x22, 0xa4, 0x02, 0x0a, 0x04, 0x4d, 0x61, 0x70, 0x73, 0x12, 0x42, + 0x0a, 0x0c, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x5f, 0x74, 0x6f, 0x5f, 0x73, 0x74, 0x72, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x73, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x6f, 0x53, 0x74, + 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0a, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x54, 0x6f, 0x53, + 0x74, 0x72, 0x12, 0x45, 0x0a, 0x0d, 0x73, 0x74, 0x72, 0x5f, 0x74, 0x6f, 0x5f, 0x6e, 0x65, 0x73, + 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x70, 0x62, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4d, 0x61, 0x70, 0x73, 0x2e, 0x53, 0x74, 0x72, 0x54, + 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x74, + 0x72, 0x54, 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x1a, 0x3d, 0x0a, 0x0f, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x54, 0x6f, 0x53, 0x74, 0x72, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x52, 0x0a, 0x10, 0x53, 0x74, 0x72, 0x54, + 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x28, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x5a, 0x0a, 0x06, + 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x31, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, + 0x74, 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x6f, + 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x22, 0x94, 0x04, 0x0a, 0x05, 0x4e, 0x65, 0x73, + 0x74, 0x73, 0x12, 0x31, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x4e, + 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x28, 0x02, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x67, + 0x72, 0x6f, 0x75, 0x70, 0x12, 0x31, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x72, 0x70, + 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x3f, 0x0a, 0x08, 0x72, 0x70, 0x74, 0x67, 0x72, + 0x6f, 0x75, 0x70, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x70, 0x62, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x73, 0x2e, 0x52, 0x70, 0x74, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x07, 0xaa, 0x01, 0x04, 0x18, 0x02, 0x28, 0x02, 0x52, 0x08, + 0x72, 0x70, 0x74, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x1a, 0xe9, 0x01, 0x0a, 0x08, 0x4f, 0x70, 0x74, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x12, 0x31, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x6f, 0x70, + 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x58, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x6e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x29, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, + 0x74, 0x73, 0x2e, 0x4f, 0x70, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x2e, 0x4f, 0x70, 0x74, 0x4e, + 0x65, 0x73, 0x74, 0x65, 0x64, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x28, + 0x02, 0x52, 0x0e, 0x6f, 0x70, 0x74, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x1a, 0x31, 0x0a, 0x0e, 0x4f, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x12, 0x1f, 0x0a, 0x0b, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, + 0x33, 0x32, 0x18, 0x01, 0x20, 0x01, 0x28, 0x07, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x46, 0x69, 0x78, + 0x65, 0x64, 0x33, 0x32, 0x1a, 0x29, 0x0a, 0x08, 0x52, 0x70, 0x74, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x1d, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, + 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x72, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, + 0x0e, 0x72, 0x65, 0x73, 0x65, 0x72, 0x76, 0x65, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x22, + 0x91, 0x02, 0x0a, 0x09, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x73, 0x12, 0x20, 0x0a, + 0x08, 0x72, 0x65, 0x71, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x42, + 0x05, 0xaa, 0x01, 0x02, 0x08, 0x03, 0x52, 0x07, 0x72, 0x65, 0x71, 0x42, 0x6f, 0x6f, 0x6c, 0x12, + 0x28, 0x0a, 0x0c, 0x72, 0x65, 0x71, 0x5f, 0x73, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x10, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x03, 0x52, 0x0b, 0x72, 0x65, + 0x71, 0x53, 0x66, 0x69, 0x78, 0x65, 0x64, 0x36, 0x34, 0x12, 0x24, 0x0a, 0x0a, 0x72, 0x65, 0x71, + 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x42, 0x05, 0xaa, + 0x01, 0x02, 0x08, 0x03, 0x52, 0x09, 0x72, 0x65, 0x71, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, + 0x24, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x04, 0x20, + 0x01, 0x28, 0x09, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x03, 0x52, 0x09, 0x72, 0x65, 0x71, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x32, 0x0a, 0x08, 0x72, 0x65, 0x71, 0x5f, 0x65, 0x6e, 0x75, + 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x03, + 0x52, 0x07, 0x72, 0x65, 0x71, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x38, 0x0a, 0x0a, 0x72, 0x65, 0x71, + 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, + 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x03, 0x52, 0x09, 0x72, 0x65, 0x71, 0x4e, 0x65, 0x73, + 0x74, 0x65, 0x64, 0x22, 0x56, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x24, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x5f, 0x73, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, + 0x03, 0x52, 0x09, 0x72, 0x65, 0x71, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x1d, 0x0a, 0x0a, + 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x3a, 0x0a, 0x12, 0x4e, + 0x65, 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, + 0x64, 0x12, 0x24, 0x0a, 0x0a, 0x72, 0x65, 0x71, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x03, 0x52, 0x09, 0x72, 0x65, + 0x71, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x22, 0x98, 0x03, 0x0a, 0x10, 0x49, 0x6e, 0x64, 0x69, + 0x72, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x12, 0x44, 0x0a, 0x0a, + 0x6f, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, + 0x42, 0x05, 0xaa, 0x01, 0x02, 0x08, 0x03, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x12, 0x3d, 0x0a, 0x0a, 0x72, 0x70, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x52, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x09, 0x72, 0x70, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, + 0x64, 0x12, 0x51, 0x0a, 0x0d, 0x73, 0x74, 0x72, 0x5f, 0x74, 0x6f, 0x5f, 0x6e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2d, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x49, 0x6e, 0x64, 0x69, 0x72, 0x65, 0x63, 0x74, 0x52, 0x65, + 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x2e, 0x53, 0x74, 0x72, 0x54, 0x6f, 0x4e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x74, 0x72, 0x54, 0x6f, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x12, 0x43, 0x0a, 0x0c, 0x6f, 0x6e, 0x65, 0x6f, 0x66, 0x5f, 0x6e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x70, 0x62, 0x65, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x57, 0x69, + 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x48, 0x00, 0x52, 0x0b, 0x6f, 0x6e, + 0x65, 0x6f, 0x66, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x1a, 0x5e, 0x0a, 0x10, 0x53, 0x74, 0x72, + 0x54, 0x6f, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x34, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1e, + 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, + 0x65, 0x64, 0x57, 0x69, 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x42, 0x07, 0x0a, 0x05, 0x75, 0x6e, 0x69, + 0x6f, 0x6e, 0x22, 0x69, 0x0a, 0x0a, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, + 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, + 0x19, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x65, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x6f, 0x70, + 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x08, 0x6f, + 0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x2a, 0x04, 0x08, 0x14, 0x10, 0x65, 0x22, 0xe4, 0x04, + 0x0a, 0x13, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x43, 0x6f, 0x6e, 0x74, + 0x61, 0x69, 0x6e, 0x65, 0x72, 0x32, 0x38, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, + 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x33, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x32, + 0x3c, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, + 0x67, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, + 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x34, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x0c, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x4a, 0x0a, + 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x16, 0x2e, + 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x35, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x70, 0x62, + 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x6f, + 0x70, 0x74, 0x45, 0x78, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x32, 0x50, 0x0a, 0x0e, 0x6f, 0x70, 0x74, + 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x16, 0x2e, 0x70, 0x62, + 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x36, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x0c, 0x6f, + 0x70, 0x74, 0x45, 0x78, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x32, 0x5b, 0x0a, 0x0f, 0x6f, + 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x16, + 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, + 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x37, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x70, + 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, + 0x6c, 0x52, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x45, 0x78, + 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x32, 0x3c, 0x0a, 0x0e, 0x72, 0x70, 0x74, 0x5f, + 0x65, 0x78, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x73, 0x18, 0x3d, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, + 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x4a, 0x0a, 0x0c, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x78, + 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x3e, + 0x20, 0x03, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x45, 0x6e, + 0x75, 0x6d, 0x32, 0x50, 0x0a, 0x0e, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x6e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x3f, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x0c, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x22, 0x1a, 0x0a, 0x0a, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, + 0x65, 0x74, 0x2a, 0x08, 0x08, 0x04, 0x10, 0xff, 0xff, 0xff, 0xff, 0x07, 0x3a, 0x02, 0x08, 0x01, + 0x22, 0xe0, 0x02, 0x0a, 0x13, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, + 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, + 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x6f, 0x70, + 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x6b, 0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, + 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, + 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, + 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x72, 0x0a, 0x19, 0x6e, 0x6f, 0x74, 0x5f, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4d, + 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1f, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, + 0x52, 0x16, 0x6e, 0x6f, 0x74, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, + 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x32, 0x49, 0x0a, 0x0a, 0x65, 0x78, 0x74, 0x5f, + 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x1e, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x09, 0x65, 0x78, 0x74, 0x4e, 0x65, 0x73, + 0x74, 0x65, 0x64, 0x22, 0x1a, 0x0a, 0x0e, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x53, 0x65, 0x74, 0x2a, 0x08, 0x08, 0x04, 0x10, 0x80, 0x80, 0x80, 0x80, 0x02, 0x22, + 0xad, 0x01, 0x0a, 0x17, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, + 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x1d, 0x0a, 0x0a, 0x6f, + 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x09, 0x6f, 0x70, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x32, 0x73, 0x0a, 0x15, 0x6d, 0x65, + 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, + 0x69, 0x6f, 0x6e, 0x12, 0x1a, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x2e, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, + 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, + 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x22, + 0x9e, 0x08, 0x0a, 0x0a, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, 0x65, 0x73, 0x12, 0x35, + 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x62, 0x6f, 0x6f, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, + 0x75, 0x66, 0x2e, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x6f, 0x70, + 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x12, 0x38, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, + 0x33, 0x32, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, + 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x33, 0x32, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x12, + 0x38, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, + 0x08, 0x6f, 0x70, 0x74, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x3b, 0x0a, 0x0a, 0x6f, 0x70, 0x74, + 0x5f, 0x75, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, + 0x55, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x09, 0x6f, 0x70, 0x74, + 0x55, 0x69, 0x6e, 0x74, 0x33, 0x32, 0x12, 0x3b, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x75, 0x69, + 0x6e, 0x74, 0x36, 0x34, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x55, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x09, 0x6f, 0x70, 0x74, 0x55, 0x69, 0x6e, + 0x74, 0x36, 0x34, 0x12, 0x38, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x6c, 0x6f, 0x61, 0x74, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x12, 0x3b, 0x0a, + 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x64, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, + 0x09, 0x6f, 0x70, 0x74, 0x44, 0x6f, 0x75, 0x62, 0x6c, 0x65, 0x12, 0x3b, 0x0a, 0x0a, 0x6f, 0x70, + 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x09, 0x6f, 0x70, + 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, 0x38, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x62, + 0x79, 0x74, 0x65, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x12, 0x3c, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x19, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x0b, 0x6f, 0x70, 0x74, 0x44, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, + 0x3f, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, + 0x6d, 0x70, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x12, 0x36, 0x0a, 0x0a, 0x6f, 0x70, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x75, 0x63, 0x74, 0x18, 0x19, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x52, 0x09, 0x6f, + 0x70, 0x74, 0x53, 0x74, 0x72, 0x75, 0x63, 0x74, 0x12, 0x35, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, + 0x6c, 0x69, 0x73, 0x74, 0x18, 0x1a, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, + 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x4c, 0x69, 0x73, 0x74, 0x12, + 0x33, 0x0a, 0x09, 0x6f, 0x70, 0x74, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x1b, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x16, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x35, 0x0a, 0x08, 0x6f, 0x70, 0x74, 0x5f, 0x6e, 0x75, 0x6c, 0x6c, + 0x18, 0x1c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x4e, 0x75, 0x6c, 0x6c, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x52, 0x07, 0x6f, 0x70, 0x74, 0x4e, 0x75, 0x6c, 0x6c, 0x12, 0x33, 0x0a, 0x09, 0x6f, + 0x70, 0x74, 0x5f, 0x65, 0x6d, 0x70, 0x74, 0x79, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x16, + 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, + 0x2e, 0x45, 0x6d, 0x70, 0x74, 0x79, 0x52, 0x08, 0x6f, 0x70, 0x74, 0x45, 0x6d, 0x70, 0x74, 0x79, + 0x12, 0x2d, 0x0a, 0x07, 0x6f, 0x70, 0x74, 0x5f, 0x61, 0x6e, 0x79, 0x18, 0x20, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x14, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2e, 0x41, 0x6e, 0x79, 0x52, 0x06, 0x6f, 0x70, 0x74, 0x41, 0x6e, 0x79, 0x12, + 0x3f, 0x0a, 0x0d, 0x6f, 0x70, 0x74, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x6d, 0x61, 0x73, 0x6b, + 0x18, 0x28, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62, 0x75, 0x66, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x4d, 0x61, + 0x73, 0x6b, 0x52, 0x0c, 0x6f, 0x70, 0x74, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x6d, 0x61, 0x73, 0x6b, + 0x2a, 0x21, 0x0a, 0x04, 0x45, 0x6e, 0x75, 0x6d, 0x12, 0x07, 0x0a, 0x03, 0x4f, 0x4e, 0x45, 0x10, + 0x01, 0x12, 0x07, 0x0a, 0x03, 0x54, 0x57, 0x4f, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, 0x54, 0x45, + 0x4e, 0x10, 0x0a, 0x3a, 0x38, 0x0a, 0x0c, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x62, + 0x6f, 0x6f, 0x6c, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x15, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0a, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x42, 0x6f, 0x6f, 0x6c, 0x3a, 0x3c, 0x0a, + 0x0e, 0x6f, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x12, + 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, + 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x16, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x6f, + 0x70, 0x74, 0x45, 0x78, 0x74, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x3a, 0x4a, 0x0a, 0x0c, 0x6f, + 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x16, 0x2e, 0x70, 0x62, + 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, + 0x6f, 0x6e, 0x73, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x70, 0x62, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x6f, 0x70, 0x74, + 0x45, 0x78, 0x74, 0x45, 0x6e, 0x75, 0x6d, 0x3a, 0x50, 0x0a, 0x0e, 0x6f, 0x70, 0x74, 0x5f, 0x65, + 0x78, 0x74, 0x5f, 0x6e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x18, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x0c, 0x6f, 0x70, 0x74, + 0x45, 0x78, 0x74, 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x3a, 0x5b, 0x0a, 0x0f, 0x6f, 0x70, 0x74, + 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x12, 0x16, 0x2e, 0x70, + 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, + 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x19, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x70, 0x62, 0x65, + 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x52, + 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x64, 0x52, 0x0d, 0x6f, 0x70, 0x74, 0x45, 0x78, 0x74, 0x50, + 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x3a, 0x3e, 0x0a, 0x0f, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x78, + 0x74, 0x5f, 0x66, 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x1f, 0x20, 0x03, 0x28, 0x07, 0x52, 0x0d, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x46, + 0x69, 0x78, 0x65, 0x64, 0x33, 0x32, 0x3a, 0x4a, 0x0a, 0x0c, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x78, + 0x74, 0x5f, 0x65, 0x6e, 0x75, 0x6d, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x20, + 0x20, 0x03, 0x28, 0x0e, 0x32, 0x10, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x2e, 0x45, 0x6e, 0x75, 0x6d, 0x52, 0x0a, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x45, 0x6e, + 0x75, 0x6d, 0x3a, 0x50, 0x0a, 0x0e, 0x72, 0x70, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x5f, 0x6e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x12, 0x16, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x2e, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x21, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, + 0x4e, 0x65, 0x73, 0x74, 0x65, 0x64, 0x52, 0x0c, 0x72, 0x70, 0x74, 0x45, 0x78, 0x74, 0x4e, 0x65, + 0x73, 0x74, 0x65, 0x64, 0x3a, 0x6f, 0x0a, 0x15, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x5f, + 0x73, 0x65, 0x74, 0x5f, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x16, 0x2e, + 0x70, 0x62, 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x4d, 0x65, 0x73, 0x73, 0x61, + 0x67, 0x65, 0x53, 0x65, 0x74, 0x18, 0x32, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x70, 0x62, + 0x65, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x2e, 0x46, 0x61, 0x6b, 0x65, 0x4d, 0x65, 0x73, + 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, 0x6e, 0x73, 0x69, 0x6f, 0x6e, + 0x52, 0x13, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x53, 0x65, 0x74, 0x45, 0x78, 0x74, 0x65, + 0x6e, 0x73, 0x69, 0x6f, 0x6e, 0x42, 0x44, 0x5a, 0x3d, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, + 0x67, 0x6f, 0x6c, 0x61, 0x6e, 0x67, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x62, 0x75, 0x66, 0x2f, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2f, 0x74, 0x65, 0x73, + 0x74, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x74, 0x65, 0x78, 0x74, 0x70, 0x62, 0x65, 0x64, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x92, 0x03, 0x02, 0x10, 0x02, 0x62, 0x08, 0x65, 0x64, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x70, 0xe8, 0x07, +} + +var ( + file_internal_testprotos_textpbeditions_test2_proto_rawDescOnce sync.Once + file_internal_testprotos_textpbeditions_test2_proto_rawDescData = file_internal_testprotos_textpbeditions_test2_proto_rawDesc +) + +func file_internal_testprotos_textpbeditions_test2_proto_rawDescGZIP() []byte { + file_internal_testprotos_textpbeditions_test2_proto_rawDescOnce.Do(func() { + file_internal_testprotos_textpbeditions_test2_proto_rawDescData = protoimpl.X.CompressGZIP(file_internal_testprotos_textpbeditions_test2_proto_rawDescData) + }) + return file_internal_testprotos_textpbeditions_test2_proto_rawDescData +} + +var file_internal_testprotos_textpbeditions_test2_proto_enumTypes = make([]protoimpl.EnumInfo, 2) +var file_internal_testprotos_textpbeditions_test2_proto_msgTypes = make([]protoimpl.MessageInfo, 24) +var file_internal_testprotos_textpbeditions_test2_proto_goTypes = []interface{}{ + (Enum)(0), // 0: pbeditions.Enum + (Enums_NestedEnum)(0), // 1: pbeditions.Enums.NestedEnum + (*Scalars)(nil), // 2: pbeditions.Scalars + (*ImplicitScalars)(nil), // 3: pbeditions.ImplicitScalars + (*Enums)(nil), // 4: pbeditions.Enums + (*Repeats)(nil), // 5: pbeditions.Repeats + (*Maps)(nil), // 6: pbeditions.Maps + (*Nested)(nil), // 7: pbeditions.Nested + (*Nests)(nil), // 8: pbeditions.Nests + (*Requireds)(nil), // 9: pbeditions.Requireds + (*PartialRequired)(nil), // 10: pbeditions.PartialRequired + (*NestedWithRequired)(nil), // 11: pbeditions.NestedWithRequired + (*IndirectRequired)(nil), // 12: pbeditions.IndirectRequired + (*Extensions)(nil), // 13: pbeditions.Extensions + (*ExtensionsContainer)(nil), // 14: pbeditions.ExtensionsContainer + (*MessageSet)(nil), // 15: pbeditions.MessageSet + (*MessageSetExtension)(nil), // 16: pbeditions.MessageSetExtension + (*FakeMessageSet)(nil), // 17: pbeditions.FakeMessageSet + (*FakeMessageSetExtension)(nil), // 18: pbeditions.FakeMessageSetExtension + (*KnownTypes)(nil), // 19: pbeditions.KnownTypes + nil, // 20: pbeditions.Maps.Int32ToStrEntry + nil, // 21: pbeditions.Maps.StrToNestedEntry + (*Nests_OptGroup)(nil), // 22: pbeditions.Nests.OptGroup + (*Nests_RptGroup)(nil), // 23: pbeditions.Nests.RptGroup + (*Nests_OptGroup_OptNestedGroup)(nil), // 24: pbeditions.Nests.OptGroup.OptNestedGroup + nil, // 25: pbeditions.IndirectRequired.StrToNestedEntry + (*wrapperspb.BoolValue)(nil), // 26: google.protobuf.BoolValue + (*wrapperspb.Int32Value)(nil), // 27: google.protobuf.Int32Value + (*wrapperspb.Int64Value)(nil), // 28: google.protobuf.Int64Value + (*wrapperspb.UInt32Value)(nil), // 29: google.protobuf.UInt32Value + (*wrapperspb.UInt64Value)(nil), // 30: google.protobuf.UInt64Value + (*wrapperspb.FloatValue)(nil), // 31: google.protobuf.FloatValue + (*wrapperspb.DoubleValue)(nil), // 32: google.protobuf.DoubleValue + (*wrapperspb.StringValue)(nil), // 33: google.protobuf.StringValue + (*wrapperspb.BytesValue)(nil), // 34: google.protobuf.BytesValue + (*durationpb.Duration)(nil), // 35: google.protobuf.Duration + (*timestamppb.Timestamp)(nil), // 36: google.protobuf.Timestamp + (*structpb.Struct)(nil), // 37: google.protobuf.Struct + (*structpb.ListValue)(nil), // 38: google.protobuf.ListValue + (*structpb.Value)(nil), // 39: google.protobuf.Value + (structpb.NullValue)(0), // 40: google.protobuf.NullValue + (*emptypb.Empty)(nil), // 41: google.protobuf.Empty + (*anypb.Any)(nil), // 42: google.protobuf.Any + (*fieldmaskpb.FieldMask)(nil), // 43: google.protobuf.FieldMask +} +var file_internal_testprotos_textpbeditions_test2_proto_depIdxs = []int32{ + 0, // 0: pbeditions.Enums.opt_enum:type_name -> pbeditions.Enum + 0, // 1: pbeditions.Enums.rpt_enum:type_name -> pbeditions.Enum + 1, // 2: pbeditions.Enums.opt_nested_enum:type_name -> pbeditions.Enums.NestedEnum + 1, // 3: pbeditions.Enums.rpt_nested_enum:type_name -> pbeditions.Enums.NestedEnum + 20, // 4: pbeditions.Maps.int32_to_str:type_name -> pbeditions.Maps.Int32ToStrEntry + 21, // 5: pbeditions.Maps.str_to_nested:type_name -> pbeditions.Maps.StrToNestedEntry + 7, // 6: pbeditions.Nested.opt_nested:type_name -> pbeditions.Nested + 7, // 7: pbeditions.Nests.opt_nested:type_name -> pbeditions.Nested + 22, // 8: pbeditions.Nests.optgroup:type_name -> pbeditions.Nests.OptGroup + 7, // 9: pbeditions.Nests.rpt_nested:type_name -> pbeditions.Nested + 23, // 10: pbeditions.Nests.rptgroup:type_name -> pbeditions.Nests.RptGroup + 0, // 11: pbeditions.Requireds.req_enum:type_name -> pbeditions.Enum + 7, // 12: pbeditions.Requireds.req_nested:type_name -> pbeditions.Nested + 11, // 13: pbeditions.IndirectRequired.opt_nested:type_name -> pbeditions.NestedWithRequired + 11, // 14: pbeditions.IndirectRequired.rpt_nested:type_name -> pbeditions.NestedWithRequired + 25, // 15: pbeditions.IndirectRequired.str_to_nested:type_name -> pbeditions.IndirectRequired.StrToNestedEntry + 11, // 16: pbeditions.IndirectRequired.oneof_nested:type_name -> pbeditions.NestedWithRequired + 26, // 17: pbeditions.KnownTypes.opt_bool:type_name -> google.protobuf.BoolValue + 27, // 18: pbeditions.KnownTypes.opt_int32:type_name -> google.protobuf.Int32Value + 28, // 19: pbeditions.KnownTypes.opt_int64:type_name -> google.protobuf.Int64Value + 29, // 20: pbeditions.KnownTypes.opt_uint32:type_name -> google.protobuf.UInt32Value + 30, // 21: pbeditions.KnownTypes.opt_uint64:type_name -> google.protobuf.UInt64Value + 31, // 22: pbeditions.KnownTypes.opt_float:type_name -> google.protobuf.FloatValue + 32, // 23: pbeditions.KnownTypes.opt_double:type_name -> google.protobuf.DoubleValue + 33, // 24: pbeditions.KnownTypes.opt_string:type_name -> google.protobuf.StringValue + 34, // 25: pbeditions.KnownTypes.opt_bytes:type_name -> google.protobuf.BytesValue + 35, // 26: pbeditions.KnownTypes.opt_duration:type_name -> google.protobuf.Duration + 36, // 27: pbeditions.KnownTypes.opt_timestamp:type_name -> google.protobuf.Timestamp + 37, // 28: pbeditions.KnownTypes.opt_struct:type_name -> google.protobuf.Struct + 38, // 29: pbeditions.KnownTypes.opt_list:type_name -> google.protobuf.ListValue + 39, // 30: pbeditions.KnownTypes.opt_value:type_name -> google.protobuf.Value + 40, // 31: pbeditions.KnownTypes.opt_null:type_name -> google.protobuf.NullValue + 41, // 32: pbeditions.KnownTypes.opt_empty:type_name -> google.protobuf.Empty + 42, // 33: pbeditions.KnownTypes.opt_any:type_name -> google.protobuf.Any + 43, // 34: pbeditions.KnownTypes.opt_fieldmask:type_name -> google.protobuf.FieldMask + 7, // 35: pbeditions.Maps.StrToNestedEntry.value:type_name -> pbeditions.Nested + 7, // 36: pbeditions.Nests.OptGroup.opt_nested:type_name -> pbeditions.Nested + 24, // 37: pbeditions.Nests.OptGroup.optnestedgroup:type_name -> pbeditions.Nests.OptGroup.OptNestedGroup + 11, // 38: pbeditions.IndirectRequired.StrToNestedEntry.value:type_name -> pbeditions.NestedWithRequired + 13, // 39: pbeditions.opt_ext_bool:extendee -> pbeditions.Extensions + 13, // 40: pbeditions.opt_ext_string:extendee -> pbeditions.Extensions + 13, // 41: pbeditions.opt_ext_enum:extendee -> pbeditions.Extensions + 13, // 42: pbeditions.opt_ext_nested:extendee -> pbeditions.Extensions + 13, // 43: pbeditions.opt_ext_partial:extendee -> pbeditions.Extensions + 13, // 44: pbeditions.rpt_ext_fixed32:extendee -> pbeditions.Extensions + 13, // 45: pbeditions.rpt_ext_enum:extendee -> pbeditions.Extensions + 13, // 46: pbeditions.rpt_ext_nested:extendee -> pbeditions.Extensions + 15, // 47: pbeditions.message_set_extension:extendee -> pbeditions.MessageSet + 13, // 48: pbeditions.ExtensionsContainer.opt_ext_bool:extendee -> pbeditions.Extensions + 13, // 49: pbeditions.ExtensionsContainer.opt_ext_string:extendee -> pbeditions.Extensions + 13, // 50: pbeditions.ExtensionsContainer.opt_ext_enum:extendee -> pbeditions.Extensions + 13, // 51: pbeditions.ExtensionsContainer.opt_ext_nested:extendee -> pbeditions.Extensions + 13, // 52: pbeditions.ExtensionsContainer.opt_ext_partial:extendee -> pbeditions.Extensions + 13, // 53: pbeditions.ExtensionsContainer.rpt_ext_string:extendee -> pbeditions.Extensions + 13, // 54: pbeditions.ExtensionsContainer.rpt_ext_enum:extendee -> pbeditions.Extensions + 13, // 55: pbeditions.ExtensionsContainer.rpt_ext_nested:extendee -> pbeditions.Extensions + 15, // 56: pbeditions.MessageSetExtension.message_set_extension:extendee -> pbeditions.MessageSet + 15, // 57: pbeditions.MessageSetExtension.not_message_set_extension:extendee -> pbeditions.MessageSet + 15, // 58: pbeditions.MessageSetExtension.ext_nested:extendee -> pbeditions.MessageSet + 17, // 59: pbeditions.FakeMessageSetExtension.message_set_extension:extendee -> pbeditions.FakeMessageSet + 0, // 60: pbeditions.opt_ext_enum:type_name -> pbeditions.Enum + 7, // 61: pbeditions.opt_ext_nested:type_name -> pbeditions.Nested + 10, // 62: pbeditions.opt_ext_partial:type_name -> pbeditions.PartialRequired + 0, // 63: pbeditions.rpt_ext_enum:type_name -> pbeditions.Enum + 7, // 64: pbeditions.rpt_ext_nested:type_name -> pbeditions.Nested + 18, // 65: pbeditions.message_set_extension:type_name -> pbeditions.FakeMessageSetExtension + 0, // 66: pbeditions.ExtensionsContainer.opt_ext_enum:type_name -> pbeditions.Enum + 7, // 67: pbeditions.ExtensionsContainer.opt_ext_nested:type_name -> pbeditions.Nested + 10, // 68: pbeditions.ExtensionsContainer.opt_ext_partial:type_name -> pbeditions.PartialRequired + 0, // 69: pbeditions.ExtensionsContainer.rpt_ext_enum:type_name -> pbeditions.Enum + 7, // 70: pbeditions.ExtensionsContainer.rpt_ext_nested:type_name -> pbeditions.Nested + 16, // 71: pbeditions.MessageSetExtension.message_set_extension:type_name -> pbeditions.MessageSetExtension + 16, // 72: pbeditions.MessageSetExtension.not_message_set_extension:type_name -> pbeditions.MessageSetExtension + 7, // 73: pbeditions.MessageSetExtension.ext_nested:type_name -> pbeditions.Nested + 18, // 74: pbeditions.FakeMessageSetExtension.message_set_extension:type_name -> pbeditions.FakeMessageSetExtension + 75, // [75:75] is the sub-list for method output_type + 75, // [75:75] is the sub-list for method input_type + 60, // [60:75] is the sub-list for extension type_name + 39, // [39:60] is the sub-list for extension extendee + 0, // [0:39] is the sub-list for field type_name +} + +func init() { file_internal_testprotos_textpbeditions_test2_proto_init() } +func file_internal_testprotos_textpbeditions_test2_proto_init() { + if File_internal_testprotos_textpbeditions_test2_proto != nil { + return + } + if !protoimpl.UnsafeEnabled { + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Scalars); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ImplicitScalars); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Enums); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Repeats); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Maps); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nested); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nests); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Requireds); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PartialRequired); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*NestedWithRequired); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*IndirectRequired); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Extensions); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ExtensionsContainer); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MessageSet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*MessageSetExtension); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FakeMessageSet); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + case 3: + return &v.extensionFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*FakeMessageSetExtension); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*KnownTypes); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nests_OptGroup); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nests_RptGroup); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Nests_OptGroup_OptNestedGroup); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_internal_testprotos_textpbeditions_test2_proto_msgTypes[10].OneofWrappers = []interface{}{ + (*IndirectRequired_OneofNested)(nil), + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: file_internal_testprotos_textpbeditions_test2_proto_rawDesc, + NumEnums: 2, + NumMessages: 24, + NumExtensions: 21, + NumServices: 0, + }, + GoTypes: file_internal_testprotos_textpbeditions_test2_proto_goTypes, + DependencyIndexes: file_internal_testprotos_textpbeditions_test2_proto_depIdxs, + EnumInfos: file_internal_testprotos_textpbeditions_test2_proto_enumTypes, + MessageInfos: file_internal_testprotos_textpbeditions_test2_proto_msgTypes, + ExtensionInfos: file_internal_testprotos_textpbeditions_test2_proto_extTypes, + }.Build() + File_internal_testprotos_textpbeditions_test2_proto = out.File + file_internal_testprotos_textpbeditions_test2_proto_rawDesc = nil + file_internal_testprotos_textpbeditions_test2_proto_goTypes = nil + file_internal_testprotos_textpbeditions_test2_proto_depIdxs = nil +} diff --git a/internal/testprotos/textpbeditions/test2.proto b/internal/testprotos/textpbeditions/test2.proto new file mode 100644 index 00000000..079f0897 --- /dev/null +++ b/internal/testprotos/textpbeditions/test2.proto @@ -0,0 +1,269 @@ +// Copyright 2024 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// Test Protobuf definitions with proto2 syntax. +edition = "2023"; + +package pbeditions; + +import "google/protobuf/any.proto"; +import "google/protobuf/duration.proto"; +import "google/protobuf/empty.proto"; +import "google/protobuf/field_mask.proto"; +import "google/protobuf/struct.proto"; +import "google/protobuf/timestamp.proto"; +import "google/protobuf/wrappers.proto"; + +option go_package = "google.golang.org/protobuf/internal/testprotos/textpbeditions"; +option features.enum_type = CLOSED; + +// Scalars contains scalar fields. +message Scalars { + bool opt_bool = 1; + int32 opt_int32 = 2; + int64 opt_int64 = 3; + uint32 opt_uint32 = 4; + uint64 opt_uint64 = 5; + sint32 opt_sint32 = 6; + sint64 opt_sint64 = 7; + fixed32 opt_fixed32 = 8; + fixed64 opt_fixed64 = 9; + sfixed32 opt_sfixed32 = 10; + sfixed64 opt_sfixed64 = 11; + + // Textproto marshal outputs fields in the same order as this proto + // definition regardless of field number. Following fields are intended to + // test that assumption. + + float opt_float = 20; + double opt_double = 21; + + bytes opt_bytes = 14; + string opt_string = 13; +} + +// ImplicitScalars contains scalar field types with implicit field_presence +message ImplicitScalars { + bool s_bool = 1 [features.field_presence = IMPLICIT]; + int32 s_int32 = 2 [features.field_presence = IMPLICIT]; + int64 s_int64 = 3 [features.field_presence = IMPLICIT]; + uint32 s_uint32 = 4 [features.field_presence = IMPLICIT]; + uint64 s_uint64 = 5 [features.field_presence = IMPLICIT]; + sint32 s_sint32 = 6 [features.field_presence = IMPLICIT]; + sint64 s_sint64 = 7 [features.field_presence = IMPLICIT]; + fixed32 s_fixed32 = 8 [features.field_presence = IMPLICIT]; + fixed64 s_fixed64 = 9 [features.field_presence = IMPLICIT]; + sfixed32 s_sfixed32 = 10 [features.field_presence = IMPLICIT]; + sfixed64 s_sfixed64 = 11 [features.field_presence = IMPLICIT]; + + // Textproto marshal outputs fields in the same order as this proto + // definition regardless of field number. Following fields are intended to + // test that assumption. + + float s_float = 20 [features.field_presence = IMPLICIT]; + double s_double = 21 [features.field_presence = IMPLICIT]; + + bytes s_bytes = 14 [features.field_presence = IMPLICIT]; + string s_string = 13 [features.field_presence = IMPLICIT]; +} + +enum Enum { + ONE = 1; + TWO = 2; + TEN = 10; +} + +// Message contains enum fields. +message Enums { + Enum opt_enum = 1; + repeated Enum rpt_enum = 2; + + enum NestedEnum { + UNO = 1; + DOS = 2; + DIEZ = 10; + } + NestedEnum opt_nested_enum = 3; + repeated NestedEnum rpt_nested_enum = 4; +} + +// Message contains repeated fields. +message Repeats { + repeated bool rpt_bool = 1; + repeated int32 rpt_int32 = 2; + repeated int64 rpt_int64 = 3; + repeated uint32 rpt_uint32 = 4; + repeated uint64 rpt_uint64 = 5; + repeated float rpt_float = 6; + repeated double rpt_double = 7; + repeated string rpt_string = 8; + repeated bytes rpt_bytes = 9; +} + +// Message contains map fields. +message Maps { + map int32_to_str = 1; + map str_to_nested = 4; +} + +// Message type used as submessage. +message Nested { + string opt_string = 1; + Nested opt_nested = 2; +} + +// Message contains message and group fields. +message Nests { + Nested opt_nested = 1; + message OptGroup { + string opt_string = 1; + Nested opt_nested = 2; + + message OptNestedGroup { + fixed32 opt_fixed32 = 1; + } + OptNestedGroup optnestedgroup = 3 [features.message_encoding = DELIMITED]; + } + OptGroup optgroup = 2 [features.message_encoding = DELIMITED]; + + repeated Nested rpt_nested = 4; + message RptGroup { + repeated string rpt_string = 1; + } + + repeated RptGroup rptgroup = 5 [ + features.message_encoding = DELIMITED, + features.repeated_field_encoding = EXPANDED + ]; + + reserved reserved_field; +} + +// Message contains required fields. +message Requireds { + bool req_bool = 1 [features.field_presence = LEGACY_REQUIRED]; + sfixed64 req_sfixed64 = 2 [features.field_presence = LEGACY_REQUIRED]; + double req_double = 3 [features.field_presence = LEGACY_REQUIRED]; + string req_string = 4 [features.field_presence = LEGACY_REQUIRED]; + Enum req_enum = 5 [features.field_presence = LEGACY_REQUIRED]; + Nested req_nested = 6 [features.field_presence = LEGACY_REQUIRED]; +} + +// Message contains both required and optional fields. +message PartialRequired { + string req_string = 1 [features.field_presence = LEGACY_REQUIRED]; + string opt_string = 2; +} + +// Following messages are for testing required field nested in optional, +// repeated and map fields. + +message NestedWithRequired { + string req_string = 1 [features.field_presence = LEGACY_REQUIRED]; +} + +message IndirectRequired { + NestedWithRequired opt_nested = 1 [features.field_presence = LEGACY_REQUIRED]; + repeated NestedWithRequired rpt_nested = 2; + map str_to_nested = 3; + + oneof union { + NestedWithRequired oneof_nested = 4; + } +} + +// Following messages are for testing extensions. + +message Extensions { + string opt_string = 1; + extensions 20 to 100; + bool opt_bool = 101; + int32 opt_int32 = 2; +} + +extend Extensions { + bool opt_ext_bool = 21; + string opt_ext_string = 22; + Enum opt_ext_enum = 23; + Nested opt_ext_nested = 24; + PartialRequired opt_ext_partial = 25; + + repeated fixed32 rpt_ext_fixed32 = 31; + repeated Enum rpt_ext_enum = 32; + repeated Nested rpt_ext_nested = 33; +} + +message ExtensionsContainer { + extend Extensions { + bool opt_ext_bool = 51; + string opt_ext_string = 52; + Enum opt_ext_enum = 53; + Nested opt_ext_nested = 54; + PartialRequired opt_ext_partial = 55; + + repeated string rpt_ext_string = 61; + repeated Enum rpt_ext_enum = 62; + repeated Nested rpt_ext_nested = 63; + } +} + +// Following messages are for testing MessageSet. + +message MessageSet { + option message_set_wire_format = true; + + extensions 4 to max; +} + +message MessageSetExtension { + string opt_string = 1; + + extend MessageSet { + MessageSetExtension message_set_extension = 10; + MessageSetExtension not_message_set_extension = 20; + Nested ext_nested = 30; + } +} + +message FakeMessageSet { + extensions 4 to max; +} + +message FakeMessageSetExtension { + string opt_string = 1; + + extend FakeMessageSet { + FakeMessageSetExtension message_set_extension = 10; + } +} + +extend MessageSet { + FakeMessageSetExtension message_set_extension = 50; +} + +// Message contains well-known type fields. +message KnownTypes { + google.protobuf.BoolValue opt_bool = 1; + google.protobuf.Int32Value opt_int32 = 2; + google.protobuf.Int64Value opt_int64 = 3; + google.protobuf.UInt32Value opt_uint32 = 4; + google.protobuf.UInt64Value opt_uint64 = 5; + google.protobuf.FloatValue opt_float = 6; + google.protobuf.DoubleValue opt_double = 7; + google.protobuf.StringValue opt_string = 8; + google.protobuf.BytesValue opt_bytes = 9; + + google.protobuf.Duration opt_duration = 20; + google.protobuf.Timestamp opt_timestamp = 21; + + google.protobuf.Struct opt_struct = 25; + google.protobuf.ListValue opt_list = 26; + google.protobuf.Value opt_value = 27; + google.protobuf.NullValue opt_null = 28; + + google.protobuf.Empty opt_empty = 30; + google.protobuf.Any opt_any = 32; + + google.protobuf.FieldMask opt_fieldmask = 40; +} diff --git a/reflect/protodesc/desc_validate.go b/reflect/protodesc/desc_validate.go index 5f741dfa..e4dcaf87 100644 --- a/reflect/protodesc/desc_validate.go +++ b/reflect/protodesc/desc_validate.go @@ -107,7 +107,7 @@ func validateMessageDeclarations(ms []filedesc.Message, mds []*descriptorpb.Desc if isMessageSet && !flags.ProtoLegacy { return errors.New("message %q is a MessageSet, which is a legacy proto1 feature that is no longer supported", m.FullName()) } - if isMessageSet && (m.Syntax() != protoreflect.Proto2 || m.Fields().Len() > 0 || m.ExtensionRanges().Len() == 0) { + if isMessageSet && (m.Syntax() == protoreflect.Proto3 || m.Fields().Len() > 0 || m.ExtensionRanges().Len() == 0) { return errors.New("message %q is an invalid proto1 MessageSet", m.FullName()) } if m.Syntax() == protoreflect.Proto3 { diff --git a/testing/prototest/prototest_test.go b/testing/prototest/prototest_test.go index be9f6add..40df84c8 100644 --- a/testing/prototest/prototest_test.go +++ b/testing/prototest/prototest_test.go @@ -29,6 +29,7 @@ func Test(t *testing.T) { (*test3pb.TestAllTypes)(nil), (*testeditionspb.TestAllTypes)(nil), (*testpb.TestRequired)(nil), + (*testeditionspb.TestRequired)(nil), (*irregularpb.Message)(nil), (*testpb.TestAllExtensions)(nil), (*testeditionspb.TestAllExtensions)(nil),