// Code generated by go2proto. DO NOT EDIT.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v6.30.2
// source: model.proto

package testdatapb

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

type Enum int32

const (
	Enum_ENUM_A Enum = 0
	Enum_ENUM_B Enum = 1
)

// Enum value maps for Enum.
var (
	Enum_name = map[int32]string{
		0: "ENUM_A",
		1: "ENUM_B",
	}
	Enum_value = map[string]int32{
		"ENUM_A": 0,
		"ENUM_B": 1,
	}
)

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_model_proto_enumTypes[0].Descriptor()
}

func (Enum) Type() protoreflect.EnumType {
	return &file_model_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_model_proto_rawDescGZIP(), []int{0}
}

type Message struct {
	state          protoimpl.MessageState `protogen:"open.v1"`
	Time           *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=time,proto3" json:"time,omitempty"`
	OptTime        *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=opt_time,json=optTime,proto3,oneof" json:"opt_time,omitempty"`
	Duration       *durationpb.Duration   `protobuf:"bytes,3,opt,name=duration,proto3" json:"duration,omitempty"`
	Invalid        bool                   `protobuf:"varint,4,opt,name=invalid,proto3" json:"invalid,omitempty"`
	Nested         *Nested                `protobuf:"bytes,5,opt,name=nested,proto3" json:"nested,omitempty"`
	RepeatedNested []*Nested              `protobuf:"bytes,6,rep,name=repeated_nested,json=repeatedNested,proto3" json:"repeated_nested,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*Message) ProtoMessage() {}

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

// Deprecated: Use Message.ProtoReflect.Descriptor instead.
func (*Message) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{0}
}

func (x *Message) GetTime() *timestamppb.Timestamp {
	if x != nil {
		return x.Time
	}
	return nil
}

func (x *Message) GetOptTime() *timestamppb.Timestamp {
	if x != nil {
		return x.OptTime
	}
	return nil
}

func (x *Message) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *Message) GetInvalid() bool {
	if x != nil {
		return x.Invalid
	}
	return false
}

func (x *Message) GetNested() *Nested {
	if x != nil {
		return x.Nested
	}
	return nil
}

func (x *Message) GetRepeatedNested() []*Nested {
	if x != nil {
		return x.RepeatedNested
	}
	return nil
}

type Nested struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Nested        string                 `protobuf:"bytes,1,opt,name=nested,proto3" json:"nested,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *Nested) Reset() {
	*x = Nested{}
	mi := &file_model_proto_msgTypes[1]
	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_model_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use Nested.ProtoReflect.Descriptor instead.
func (*Nested) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{1}
}

func (x *Nested) GetNested() string {
	if x != nil {
		return x.Nested
	}
	return ""
}

type Root struct {
	state              protoimpl.MessageState            `protogen:"open.v1"`
	Int                int64                             `protobuf:"varint,1,opt,name=int,proto3" json:"int,omitempty"`
	String_            string                            `protobuf:"bytes,2,opt,name=string,proto3" json:"string,omitempty"`
	MessagePtr         *Message                          `protobuf:"bytes,4,opt,name=message_ptr,json=messagePtr,proto3" json:"message_ptr,omitempty"`
	Enum               Enum                              `protobuf:"varint,5,opt,name=enum,proto3,enum=xyz.block.ftl.go2proto.test.Enum" json:"enum,omitempty"`
	SumType            *SumType                          `protobuf:"bytes,6,opt,name=sum_type,json=sumType,proto3" json:"sum_type,omitempty"`
	OptionalInt        *int64                            `protobuf:"varint,7,opt,name=optional_int,json=optionalInt,proto3,oneof" json:"optional_int,omitempty"`
	OptionalIntPtr     *int64                            `protobuf:"varint,8,opt,name=optional_int_ptr,json=optionalIntPtr,proto3,oneof" json:"optional_int_ptr,omitempty"`
	OptionalMsg        *Message                          `protobuf:"bytes,9,opt,name=optional_msg,json=optionalMsg,proto3,oneof" json:"optional_msg,omitempty"`
	RepeatedInt        []int64                           `protobuf:"varint,10,rep,packed,name=repeated_int,json=repeatedInt,proto3" json:"repeated_int,omitempty"`
	RepeatedMsg        []*Message                        `protobuf:"bytes,11,rep,name=repeated_msg,json=repeatedMsg,proto3" json:"repeated_msg,omitempty"`
	Url                []byte                            `protobuf:"bytes,12,opt,name=url,proto3" json:"url,omitempty"`
	OptionalWrapper    *string                           `protobuf:"bytes,13,opt,name=optional_wrapper,json=optionalWrapper,proto3,oneof" json:"optional_wrapper,omitempty"`
	ExternalRoot       string                            `protobuf:"bytes,14,opt,name=external_root,json=externalRoot,proto3" json:"external_root,omitempty"`
	Key                string                            `protobuf:"bytes,15,opt,name=key,proto3" json:"key,omitempty"`
	OptionalTime       *timestamppb.Timestamp            `protobuf:"bytes,16,opt,name=optional_time,json=optionalTime,proto3,oneof" json:"optional_time,omitempty"`
	OptionalMessage    *Message                          `protobuf:"bytes,17,opt,name=optional_message,json=optionalMessage,proto3,oneof" json:"optional_message,omitempty"`
	OptionalMessagePtr *Message                          `protobuf:"bytes,18,opt,name=optional_message_ptr,json=optionalMessagePtr,proto3,oneof" json:"optional_message_ptr,omitempty"`
	Map                map[string]*timestamppb.Timestamp `protobuf:"bytes,19,rep,name=map,proto3" json:"map,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields      protoimpl.UnknownFields
	sizeCache          protoimpl.SizeCache
}

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

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

func (*Root) ProtoMessage() {}

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

// Deprecated: Use Root.ProtoReflect.Descriptor instead.
func (*Root) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{2}
}

func (x *Root) GetInt() int64 {
	if x != nil {
		return x.Int
	}
	return 0
}

func (x *Root) GetString_() string {
	if x != nil {
		return x.String_
	}
	return ""
}

func (x *Root) GetMessagePtr() *Message {
	if x != nil {
		return x.MessagePtr
	}
	return nil
}

func (x *Root) GetEnum() Enum {
	if x != nil {
		return x.Enum
	}
	return Enum_ENUM_A
}

func (x *Root) GetSumType() *SumType {
	if x != nil {
		return x.SumType
	}
	return nil
}

func (x *Root) GetOptionalInt() int64 {
	if x != nil && x.OptionalInt != nil {
		return *x.OptionalInt
	}
	return 0
}

func (x *Root) GetOptionalIntPtr() int64 {
	if x != nil && x.OptionalIntPtr != nil {
		return *x.OptionalIntPtr
	}
	return 0
}

func (x *Root) GetOptionalMsg() *Message {
	if x != nil {
		return x.OptionalMsg
	}
	return nil
}

func (x *Root) GetRepeatedInt() []int64 {
	if x != nil {
		return x.RepeatedInt
	}
	return nil
}

func (x *Root) GetRepeatedMsg() []*Message {
	if x != nil {
		return x.RepeatedMsg
	}
	return nil
}

func (x *Root) GetUrl() []byte {
	if x != nil {
		return x.Url
	}
	return nil
}

func (x *Root) GetOptionalWrapper() string {
	if x != nil && x.OptionalWrapper != nil {
		return *x.OptionalWrapper
	}
	return ""
}

func (x *Root) GetExternalRoot() string {
	if x != nil {
		return x.ExternalRoot
	}
	return ""
}

func (x *Root) GetKey() string {
	if x != nil {
		return x.Key
	}
	return ""
}

func (x *Root) GetOptionalTime() *timestamppb.Timestamp {
	if x != nil {
		return x.OptionalTime
	}
	return nil
}

func (x *Root) GetOptionalMessage() *Message {
	if x != nil {
		return x.OptionalMessage
	}
	return nil
}

func (x *Root) GetOptionalMessagePtr() *Message {
	if x != nil {
		return x.OptionalMessagePtr
	}
	return nil
}

func (x *Root) GetMap() map[string]*timestamppb.Timestamp {
	if x != nil {
		return x.Map
	}
	return nil
}

type SubSumType struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Value:
	//
	//	*SubSumType_A
	//	*SubSumType_B
	Value         isSubSumType_Value `protobuf_oneof:"value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SubSumType) ProtoMessage() {}

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

// Deprecated: Use SubSumType.ProtoReflect.Descriptor instead.
func (*SubSumType) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{3}
}

func (x *SubSumType) GetValue() isSubSumType_Value {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *SubSumType) GetA() *SubSumTypeA {
	if x != nil {
		if x, ok := x.Value.(*SubSumType_A); ok {
			return x.A
		}
	}
	return nil
}

func (x *SubSumType) GetB() *SubSumTypeB {
	if x != nil {
		if x, ok := x.Value.(*SubSumType_B); ok {
			return x.B
		}
	}
	return nil
}

type isSubSumType_Value interface {
	isSubSumType_Value()
}

type SubSumType_A struct {
	A *SubSumTypeA `protobuf:"bytes,1,opt,name=a,proto3,oneof"`
}

type SubSumType_B struct {
	B *SubSumTypeB `protobuf:"bytes,2,opt,name=b,proto3,oneof"`
}

func (*SubSumType_A) isSubSumType_Value() {}

func (*SubSumType_B) isSubSumType_Value() {}

type SubSumTypeA struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	A             string                 `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SubSumTypeA) Reset() {
	*x = SubSumTypeA{}
	mi := &file_model_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SubSumTypeA) ProtoMessage() {}

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

// Deprecated: Use SubSumTypeA.ProtoReflect.Descriptor instead.
func (*SubSumTypeA) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{4}
}

func (x *SubSumTypeA) GetA() string {
	if x != nil {
		return x.A
	}
	return ""
}

type SubSumTypeB struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	A             string                 `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SubSumTypeB) Reset() {
	*x = SubSumTypeB{}
	mi := &file_model_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SubSumTypeB) ProtoMessage() {}

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

// Deprecated: Use SubSumTypeB.ProtoReflect.Descriptor instead.
func (*SubSumTypeB) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{5}
}

func (x *SubSumTypeB) GetA() string {
	if x != nil {
		return x.A
	}
	return ""
}

type SumType struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Value:
	//
	//	*SumType_SubSumTypeA
	//	*SumType_SubSumTypeB
	//	*SumType_SumTypeA
	//	*SumType_SumTypeB
	//	*SumType_SumTypeC
	Value         isSumType_Value `protobuf_oneof:"value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SumType) Reset() {
	*x = SumType{}
	mi := &file_model_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SumType) ProtoMessage() {}

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

// Deprecated: Use SumType.ProtoReflect.Descriptor instead.
func (*SumType) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{6}
}

func (x *SumType) GetValue() isSumType_Value {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *SumType) GetSubSumTypeA() *SubSumTypeA {
	if x != nil {
		if x, ok := x.Value.(*SumType_SubSumTypeA); ok {
			return x.SubSumTypeA
		}
	}
	return nil
}

func (x *SumType) GetSubSumTypeB() *SubSumTypeB {
	if x != nil {
		if x, ok := x.Value.(*SumType_SubSumTypeB); ok {
			return x.SubSumTypeB
		}
	}
	return nil
}

func (x *SumType) GetSumTypeA() *SumTypeA {
	if x != nil {
		if x, ok := x.Value.(*SumType_SumTypeA); ok {
			return x.SumTypeA
		}
	}
	return nil
}

func (x *SumType) GetSumTypeB() *SumTypeB {
	if x != nil {
		if x, ok := x.Value.(*SumType_SumTypeB); ok {
			return x.SumTypeB
		}
	}
	return nil
}

func (x *SumType) GetSumTypeC() *SumTypeC {
	if x != nil {
		if x, ok := x.Value.(*SumType_SumTypeC); ok {
			return x.SumTypeC
		}
	}
	return nil
}

type isSumType_Value interface {
	isSumType_Value()
}

type SumType_SubSumTypeA struct {
	SubSumTypeA *SubSumTypeA `protobuf:"bytes,4,opt,name=sub_sum_type_a,json=subSumTypeA,proto3,oneof"`
}

type SumType_SubSumTypeB struct {
	SubSumTypeB *SubSumTypeB `protobuf:"bytes,5,opt,name=sub_sum_type_b,json=subSumTypeB,proto3,oneof"`
}

type SumType_SumTypeA struct {
	SumTypeA *SumTypeA `protobuf:"bytes,1,opt,name=sum_type_a,json=sumTypeA,proto3,oneof"`
}

type SumType_SumTypeB struct {
	SumTypeB *SumTypeB `protobuf:"bytes,2,opt,name=sum_type_b,json=sumTypeB,proto3,oneof"`
}

type SumType_SumTypeC struct {
	SumTypeC *SumTypeC `protobuf:"bytes,3,opt,name=sum_type_c,json=sumTypeC,proto3,oneof"`
}

func (*SumType_SubSumTypeA) isSumType_Value() {}

func (*SumType_SubSumTypeB) isSumType_Value() {}

func (*SumType_SumTypeA) isSumType_Value() {}

func (*SumType_SumTypeB) isSumType_Value() {}

func (*SumType_SumTypeC) isSumType_Value() {}

type SumTypeA struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	A             string                 `protobuf:"bytes,1,opt,name=a,proto3" json:"a,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SumTypeA) Reset() {
	*x = SumTypeA{}
	mi := &file_model_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SumTypeA) ProtoMessage() {}

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

// Deprecated: Use SumTypeA.ProtoReflect.Descriptor instead.
func (*SumTypeA) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{7}
}

func (x *SumTypeA) GetA() string {
	if x != nil {
		return x.A
	}
	return ""
}

type SumTypeB struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	B             int64                  `protobuf:"varint,1,opt,name=b,proto3" json:"b,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SumTypeB) Reset() {
	*x = SumTypeB{}
	mi := &file_model_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SumTypeB) ProtoMessage() {}

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

// Deprecated: Use SumTypeB.ProtoReflect.Descriptor instead.
func (*SumTypeB) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{8}
}

func (x *SumTypeB) GetB() int64 {
	if x != nil {
		return x.B
	}
	return 0
}

type SumTypeC struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	C             float64                `protobuf:"fixed64,1,opt,name=c,proto3" json:"c,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SumTypeC) Reset() {
	*x = SumTypeC{}
	mi := &file_model_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SumTypeC) ProtoMessage() {}

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

// Deprecated: Use SumTypeC.ProtoReflect.Descriptor instead.
func (*SumTypeC) Descriptor() ([]byte, []int) {
	return file_model_proto_rawDescGZIP(), []int{9}
}

func (x *SumTypeC) GetC() float64 {
	if x != nil {
		return x.C
	}
	return 0
}

var File_model_proto protoreflect.FileDescriptor

const file_model_proto_rawDesc = "" +
	"\n" +
	"\vmodel.proto\x12\x1bxyz.block.ftl.go2proto.test\x1a\x1fgoogle/protobuf/timestamp.proto\x1a\x1egoogle/protobuf/duration.proto\"\xde\x02\n" +
	"\aMessage\x12.\n" +
	"\x04time\x18\x01 \x01(\v2\x1a.google.protobuf.TimestampR\x04time\x12:\n" +
	"\bopt_time\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampH\x00R\aoptTime\x88\x01\x01\x125\n" +
	"\bduration\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\bduration\x12\x18\n" +
	"\ainvalid\x18\x04 \x01(\bR\ainvalid\x12;\n" +
	"\x06nested\x18\x05 \x01(\v2#.xyz.block.ftl.go2proto.test.NestedR\x06nested\x12L\n" +
	"\x0frepeated_nested\x18\x06 \x03(\v2#.xyz.block.ftl.go2proto.test.NestedR\x0erepeatedNestedB\v\n" +
	"\t_opt_time\" \n" +
	"\x06Nested\x12\x16\n" +
	"\x06nested\x18\x01 \x01(\tR\x06nested\"\x90\t\n" +
	"\x04Root\x12\x10\n" +
	"\x03int\x18\x01 \x01(\x03R\x03int\x12\x16\n" +
	"\x06string\x18\x02 \x01(\tR\x06string\x12E\n" +
	"\vmessage_ptr\x18\x04 \x01(\v2$.xyz.block.ftl.go2proto.test.MessageR\n" +
	"messagePtr\x125\n" +
	"\x04enum\x18\x05 \x01(\x0e2!.xyz.block.ftl.go2proto.test.EnumR\x04enum\x12?\n" +
	"\bsum_type\x18\x06 \x01(\v2$.xyz.block.ftl.go2proto.test.SumTypeR\asumType\x12&\n" +
	"\foptional_int\x18\a \x01(\x03H\x00R\voptionalInt\x88\x01\x01\x12-\n" +
	"\x10optional_int_ptr\x18\b \x01(\x03H\x01R\x0eoptionalIntPtr\x88\x01\x01\x12L\n" +
	"\foptional_msg\x18\t \x01(\v2$.xyz.block.ftl.go2proto.test.MessageH\x02R\voptionalMsg\x88\x01\x01\x12!\n" +
	"\frepeated_int\x18\n" +
	" \x03(\x03R\vrepeatedInt\x12G\n" +
	"\frepeated_msg\x18\v \x03(\v2$.xyz.block.ftl.go2proto.test.MessageR\vrepeatedMsg\x12\x10\n" +
	"\x03url\x18\f \x01(\fR\x03url\x12.\n" +
	"\x10optional_wrapper\x18\r \x01(\tH\x03R\x0foptionalWrapper\x88\x01\x01\x12#\n" +
	"\rexternal_root\x18\x0e \x01(\tR\fexternalRoot\x12\x10\n" +
	"\x03key\x18\x0f \x01(\tR\x03key\x12D\n" +
	"\roptional_time\x18\x10 \x01(\v2\x1a.google.protobuf.TimestampH\x04R\foptionalTime\x88\x01\x01\x12T\n" +
	"\x10optional_message\x18\x11 \x01(\v2$.xyz.block.ftl.go2proto.test.MessageH\x05R\x0foptionalMessage\x88\x01\x01\x12[\n" +
	"\x14optional_message_ptr\x18\x12 \x01(\v2$.xyz.block.ftl.go2proto.test.MessageH\x06R\x12optionalMessagePtr\x88\x01\x01\x12<\n" +
	"\x03map\x18\x13 \x03(\v2*.xyz.block.ftl.go2proto.test.Root.MapEntryR\x03map\x1aR\n" +
	"\bMapEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x120\n" +
	"\x05value\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x05value:\x028\x01B\x0f\n" +
	"\r_optional_intB\x13\n" +
	"\x11_optional_int_ptrB\x0f\n" +
	"\r_optional_msgB\x13\n" +
	"\x11_optional_wrapperB\x10\n" +
	"\x0e_optional_timeB\x13\n" +
	"\x11_optional_messageB\x17\n" +
	"\x15_optional_message_ptr\"\x89\x01\n" +
	"\n" +
	"SubSumType\x128\n" +
	"\x01a\x18\x01 \x01(\v2(.xyz.block.ftl.go2proto.test.SubSumTypeAH\x00R\x01a\x128\n" +
	"\x01b\x18\x02 \x01(\v2(.xyz.block.ftl.go2proto.test.SubSumTypeBH\x00R\x01bB\a\n" +
	"\x05value\"\x1b\n" +
	"\vSubSumTypeA\x12\f\n" +
	"\x01a\x18\x01 \x01(\tR\x01a\"\x1b\n" +
	"\vSubSumTypeB\x12\f\n" +
	"\x01a\x18\x01 \x01(\tR\x01a\"\x89\x03\n" +
	"\aSumType\x12O\n" +
	"\x0esub_sum_type_a\x18\x04 \x01(\v2(.xyz.block.ftl.go2proto.test.SubSumTypeAH\x00R\vsubSumTypeA\x12O\n" +
	"\x0esub_sum_type_b\x18\x05 \x01(\v2(.xyz.block.ftl.go2proto.test.SubSumTypeBH\x00R\vsubSumTypeB\x12E\n" +
	"\n" +
	"sum_type_a\x18\x01 \x01(\v2%.xyz.block.ftl.go2proto.test.SumTypeAH\x00R\bsumTypeA\x12E\n" +
	"\n" +
	"sum_type_b\x18\x02 \x01(\v2%.xyz.block.ftl.go2proto.test.SumTypeBH\x00R\bsumTypeB\x12E\n" +
	"\n" +
	"sum_type_c\x18\x03 \x01(\v2%.xyz.block.ftl.go2proto.test.SumTypeCH\x00R\bsumTypeCB\a\n" +
	"\x05value\"\x18\n" +
	"\bSumTypeA\x12\f\n" +
	"\x01a\x18\x01 \x01(\tR\x01a\"\x18\n" +
	"\bSumTypeB\x12\f\n" +
	"\x01b\x18\x01 \x01(\x03R\x01b\"\x18\n" +
	"\bSumTypeC\x12\f\n" +
	"\x01c\x18\x01 \x01(\x01R\x01c*\x1e\n" +
	"\x04Enum\x12\n" +
	"\n" +
	"\x06ENUM_A\x10\x00\x12\n" +
	"\n" +
	"\x06ENUM_B\x10\x01B7Z5github.com/block/ftl/cmd/go2proto/testdata/testdatapbb\x06proto3"

var (
	file_model_proto_rawDescOnce sync.Once
	file_model_proto_rawDescData []byte
)

func file_model_proto_rawDescGZIP() []byte {
	file_model_proto_rawDescOnce.Do(func() {
		file_model_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_model_proto_rawDesc), len(file_model_proto_rawDesc)))
	})
	return file_model_proto_rawDescData
}

var file_model_proto_enumTypes = make([]protoimpl.EnumInfo, 1)
var file_model_proto_msgTypes = make([]protoimpl.MessageInfo, 11)
var file_model_proto_goTypes = []any{
	(Enum)(0),                     // 0: xyz.block.ftl.go2proto.test.Enum
	(*Message)(nil),               // 1: xyz.block.ftl.go2proto.test.Message
	(*Nested)(nil),                // 2: xyz.block.ftl.go2proto.test.Nested
	(*Root)(nil),                  // 3: xyz.block.ftl.go2proto.test.Root
	(*SubSumType)(nil),            // 4: xyz.block.ftl.go2proto.test.SubSumType
	(*SubSumTypeA)(nil),           // 5: xyz.block.ftl.go2proto.test.SubSumTypeA
	(*SubSumTypeB)(nil),           // 6: xyz.block.ftl.go2proto.test.SubSumTypeB
	(*SumType)(nil),               // 7: xyz.block.ftl.go2proto.test.SumType
	(*SumTypeA)(nil),              // 8: xyz.block.ftl.go2proto.test.SumTypeA
	(*SumTypeB)(nil),              // 9: xyz.block.ftl.go2proto.test.SumTypeB
	(*SumTypeC)(nil),              // 10: xyz.block.ftl.go2proto.test.SumTypeC
	nil,                           // 11: xyz.block.ftl.go2proto.test.Root.MapEntry
	(*timestamppb.Timestamp)(nil), // 12: google.protobuf.Timestamp
	(*durationpb.Duration)(nil),   // 13: google.protobuf.Duration
}
var file_model_proto_depIdxs = []int32{
	12, // 0: xyz.block.ftl.go2proto.test.Message.time:type_name -> google.protobuf.Timestamp
	12, // 1: xyz.block.ftl.go2proto.test.Message.opt_time:type_name -> google.protobuf.Timestamp
	13, // 2: xyz.block.ftl.go2proto.test.Message.duration:type_name -> google.protobuf.Duration
	2,  // 3: xyz.block.ftl.go2proto.test.Message.nested:type_name -> xyz.block.ftl.go2proto.test.Nested
	2,  // 4: xyz.block.ftl.go2proto.test.Message.repeated_nested:type_name -> xyz.block.ftl.go2proto.test.Nested
	1,  // 5: xyz.block.ftl.go2proto.test.Root.message_ptr:type_name -> xyz.block.ftl.go2proto.test.Message
	0,  // 6: xyz.block.ftl.go2proto.test.Root.enum:type_name -> xyz.block.ftl.go2proto.test.Enum
	7,  // 7: xyz.block.ftl.go2proto.test.Root.sum_type:type_name -> xyz.block.ftl.go2proto.test.SumType
	1,  // 8: xyz.block.ftl.go2proto.test.Root.optional_msg:type_name -> xyz.block.ftl.go2proto.test.Message
	1,  // 9: xyz.block.ftl.go2proto.test.Root.repeated_msg:type_name -> xyz.block.ftl.go2proto.test.Message
	12, // 10: xyz.block.ftl.go2proto.test.Root.optional_time:type_name -> google.protobuf.Timestamp
	1,  // 11: xyz.block.ftl.go2proto.test.Root.optional_message:type_name -> xyz.block.ftl.go2proto.test.Message
	1,  // 12: xyz.block.ftl.go2proto.test.Root.optional_message_ptr:type_name -> xyz.block.ftl.go2proto.test.Message
	11, // 13: xyz.block.ftl.go2proto.test.Root.map:type_name -> xyz.block.ftl.go2proto.test.Root.MapEntry
	5,  // 14: xyz.block.ftl.go2proto.test.SubSumType.a:type_name -> xyz.block.ftl.go2proto.test.SubSumTypeA
	6,  // 15: xyz.block.ftl.go2proto.test.SubSumType.b:type_name -> xyz.block.ftl.go2proto.test.SubSumTypeB
	5,  // 16: xyz.block.ftl.go2proto.test.SumType.sub_sum_type_a:type_name -> xyz.block.ftl.go2proto.test.SubSumTypeA
	6,  // 17: xyz.block.ftl.go2proto.test.SumType.sub_sum_type_b:type_name -> xyz.block.ftl.go2proto.test.SubSumTypeB
	8,  // 18: xyz.block.ftl.go2proto.test.SumType.sum_type_a:type_name -> xyz.block.ftl.go2proto.test.SumTypeA
	9,  // 19: xyz.block.ftl.go2proto.test.SumType.sum_type_b:type_name -> xyz.block.ftl.go2proto.test.SumTypeB
	10, // 20: xyz.block.ftl.go2proto.test.SumType.sum_type_c:type_name -> xyz.block.ftl.go2proto.test.SumTypeC
	12, // 21: xyz.block.ftl.go2proto.test.Root.MapEntry.value:type_name -> google.protobuf.Timestamp
	22, // [22:22] is the sub-list for method output_type
	22, // [22:22] is the sub-list for method input_type
	22, // [22:22] is the sub-list for extension type_name
	22, // [22:22] is the sub-list for extension extendee
	0,  // [0:22] is the sub-list for field type_name
}

func init() { file_model_proto_init() }
func file_model_proto_init() {
	if File_model_proto != nil {
		return
	}
	file_model_proto_msgTypes[0].OneofWrappers = []any{}
	file_model_proto_msgTypes[2].OneofWrappers = []any{}
	file_model_proto_msgTypes[3].OneofWrappers = []any{
		(*SubSumType_A)(nil),
		(*SubSumType_B)(nil),
	}
	file_model_proto_msgTypes[6].OneofWrappers = []any{
		(*SumType_SubSumTypeA)(nil),
		(*SumType_SubSumTypeB)(nil),
		(*SumType_SumTypeA)(nil),
		(*SumType_SumTypeB)(nil),
		(*SumType_SumTypeC)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_model_proto_rawDesc), len(file_model_proto_rawDesc)),
			NumEnums:      1,
			NumMessages:   11,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_model_proto_goTypes,
		DependencyIndexes: file_model_proto_depIdxs,
		EnumInfos:         file_model_proto_enumTypes,
		MessageInfos:      file_model_proto_msgTypes,
	}.Build()
	File_model_proto = out.File
	file_model_proto_goTypes = nil
	file_model_proto_depIdxs = nil
}
