mautrix-signal/pkg/signalmeow/protobuf/UnidentifiedDelivery.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.33.5
// source: UnidentifiedDelivery.proto

// Copyright 2018 Signal Messenger, LLC
// SPDX-License-Identifier: AGPL-3.0-only

package signalpb

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	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 UnidentifiedSenderMessage_Message_Type int32

const (
	// Our parser does not handle reserved in enums: DESKTOP-1569
	// reserved 1;
	UnidentifiedSenderMessage_Message_MESSAGE           UnidentifiedSenderMessage_Message_Type = 2
	UnidentifiedSenderMessage_Message_PREKEY_MESSAGE    UnidentifiedSenderMessage_Message_Type = 3 // Further cases should line up with Envelope.Type, even though old cases don't.
	UnidentifiedSenderMessage_Message_SENDERKEY_MESSAGE UnidentifiedSenderMessage_Message_Type = 7
	UnidentifiedSenderMessage_Message_PLAINTEXT_CONTENT UnidentifiedSenderMessage_Message_Type = 8
)

// Enum value maps for UnidentifiedSenderMessage_Message_Type.
var (
	UnidentifiedSenderMessage_Message_Type_name = map[int32]string{
		2: "MESSAGE",
		3: "PREKEY_MESSAGE",
		7: "SENDERKEY_MESSAGE",
		8: "PLAINTEXT_CONTENT",
	}
	UnidentifiedSenderMessage_Message_Type_value = map[string]int32{
		"MESSAGE":           2,
		"PREKEY_MESSAGE":    3,
		"SENDERKEY_MESSAGE": 7,
		"PLAINTEXT_CONTENT": 8,
	}
)

func (x UnidentifiedSenderMessage_Message_Type) Enum() *UnidentifiedSenderMessage_Message_Type {
	p := new(UnidentifiedSenderMessage_Message_Type)
	*p = x
	return p
}

func (x UnidentifiedSenderMessage_Message_Type) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (UnidentifiedSenderMessage_Message_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_UnidentifiedDelivery_proto_enumTypes[0].Descriptor()
}

func (UnidentifiedSenderMessage_Message_Type) Type() protoreflect.EnumType {
	return &file_UnidentifiedDelivery_proto_enumTypes[0]
}

func (x UnidentifiedSenderMessage_Message_Type) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Do not use.
func (x *UnidentifiedSenderMessage_Message_Type) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = UnidentifiedSenderMessage_Message_Type(num)
	return nil
}

// Deprecated: Use UnidentifiedSenderMessage_Message_Type.Descriptor instead.
func (UnidentifiedSenderMessage_Message_Type) EnumDescriptor() ([]byte, []int) {
	return file_UnidentifiedDelivery_proto_rawDescGZIP(), []int{2, 0, 0}
}

type UnidentifiedSenderMessage_Message_ContentHint int32

const (
	// Show an error immediately; it was important but we can't retry.
	UnidentifiedSenderMessage_Message_DEFAULT UnidentifiedSenderMessage_Message_ContentHint = 0
	// Sender will try to resend; delay any error UI if possible
	UnidentifiedSenderMessage_Message_RESENDABLE UnidentifiedSenderMessage_Message_ContentHint = 1
	// Don't show any error UI at all; this is something sent implicitly like a typing message or a receipt
	UnidentifiedSenderMessage_Message_IMPLICIT UnidentifiedSenderMessage_Message_ContentHint = 2
)

// Enum value maps for UnidentifiedSenderMessage_Message_ContentHint.
var (
	UnidentifiedSenderMessage_Message_ContentHint_name = map[int32]string{
		0: "DEFAULT",
		1: "RESENDABLE",
		2: "IMPLICIT",
	}
	UnidentifiedSenderMessage_Message_ContentHint_value = map[string]int32{
		"DEFAULT":    0,
		"RESENDABLE": 1,
		"IMPLICIT":   2,
	}
)

func (x UnidentifiedSenderMessage_Message_ContentHint) Enum() *UnidentifiedSenderMessage_Message_ContentHint {
	p := new(UnidentifiedSenderMessage_Message_ContentHint)
	*p = x
	return p
}

func (x UnidentifiedSenderMessage_Message_ContentHint) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (UnidentifiedSenderMessage_Message_ContentHint) Descriptor() protoreflect.EnumDescriptor {
	return file_UnidentifiedDelivery_proto_enumTypes[1].Descriptor()
}

func (UnidentifiedSenderMessage_Message_ContentHint) Type() protoreflect.EnumType {
	return &file_UnidentifiedDelivery_proto_enumTypes[1]
}

func (x UnidentifiedSenderMessage_Message_ContentHint) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Do not use.
func (x *UnidentifiedSenderMessage_Message_ContentHint) UnmarshalJSON(b []byte) error {
	num, err := protoimpl.X.UnmarshalJSONEnum(x.Descriptor(), b)
	if err != nil {
		return err
	}
	*x = UnidentifiedSenderMessage_Message_ContentHint(num)
	return nil
}

// Deprecated: Use UnidentifiedSenderMessage_Message_ContentHint.Descriptor instead.
func (UnidentifiedSenderMessage_Message_ContentHint) EnumDescriptor() ([]byte, []int) {
	return file_UnidentifiedDelivery_proto_rawDescGZIP(), []int{2, 0, 1}
}

type ServerCertificate struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Certificate   []byte                 `protobuf:"bytes,1,opt,name=certificate" json:"certificate,omitempty"`
	Signature     []byte                 `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerCertificate) ProtoMessage() {}

func (x *ServerCertificate) ProtoReflect() protoreflect.Message {
	mi := &file_UnidentifiedDelivery_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 ServerCertificate.ProtoReflect.Descriptor instead.
func (*ServerCertificate) Descriptor() ([]byte, []int) {
	return file_UnidentifiedDelivery_proto_rawDescGZIP(), []int{0}
}

func (x *ServerCertificate) GetCertificate() []byte {
	if x != nil {
		return x.Certificate
	}
	return nil
}

func (x *ServerCertificate) GetSignature() []byte {
	if x != nil {
		return x.Signature
	}
	return nil
}

type SenderCertificate struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Certificate   []byte                 `protobuf:"bytes,1,opt,name=certificate" json:"certificate,omitempty"`
	Signature     []byte                 `protobuf:"bytes,2,opt,name=signature" json:"signature,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SenderCertificate) Reset() {
	*x = SenderCertificate{}
	mi := &file_UnidentifiedDelivery_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SenderCertificate) ProtoMessage() {}

func (x *SenderCertificate) ProtoReflect() protoreflect.Message {
	mi := &file_UnidentifiedDelivery_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 SenderCertificate.ProtoReflect.Descriptor instead.
func (*SenderCertificate) Descriptor() ([]byte, []int) {
	return file_UnidentifiedDelivery_proto_rawDescGZIP(), []int{1}
}

func (x *SenderCertificate) GetCertificate() []byte {
	if x != nil {
		return x.Certificate
	}
	return nil
}

func (x *SenderCertificate) GetSignature() []byte {
	if x != nil {
		return x.Signature
	}
	return nil
}

type UnidentifiedSenderMessage struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	EphemeralPublic  []byte                 `protobuf:"bytes,1,opt,name=ephemeralPublic" json:"ephemeralPublic,omitempty"`
	EncryptedStatic  []byte                 `protobuf:"bytes,2,opt,name=encryptedStatic" json:"encryptedStatic,omitempty"`
	EncryptedMessage []byte                 `protobuf:"bytes,3,opt,name=encryptedMessage" json:"encryptedMessage,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*UnidentifiedSenderMessage) ProtoMessage() {}

func (x *UnidentifiedSenderMessage) ProtoReflect() protoreflect.Message {
	mi := &file_UnidentifiedDelivery_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 UnidentifiedSenderMessage.ProtoReflect.Descriptor instead.
func (*UnidentifiedSenderMessage) Descriptor() ([]byte, []int) {
	return file_UnidentifiedDelivery_proto_rawDescGZIP(), []int{2}
}

func (x *UnidentifiedSenderMessage) GetEphemeralPublic() []byte {
	if x != nil {
		return x.EphemeralPublic
	}
	return nil
}

func (x *UnidentifiedSenderMessage) GetEncryptedStatic() []byte {
	if x != nil {
		return x.EncryptedStatic
	}
	return nil
}

func (x *UnidentifiedSenderMessage) GetEncryptedMessage() []byte {
	if x != nil {
		return x.EncryptedMessage
	}
	return nil
}

type ServerCertificate_Certificate struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Id            *uint32                `protobuf:"varint,1,opt,name=id" json:"id,omitempty"`
	Key           []byte                 `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ServerCertificate_Certificate) ProtoMessage() {}

func (x *ServerCertificate_Certificate) ProtoReflect() protoreflect.Message {
	mi := &file_UnidentifiedDelivery_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 ServerCertificate_Certificate.ProtoReflect.Descriptor instead.
func (*ServerCertificate_Certificate) Descriptor() ([]byte, []int) {
	return file_UnidentifiedDelivery_proto_rawDescGZIP(), []int{0, 0}
}

func (x *ServerCertificate_Certificate) GetId() uint32 {
	if x != nil && x.Id != nil {
		return *x.Id
	}
	return 0
}

func (x *ServerCertificate_Certificate) GetKey() []byte {
	if x != nil {
		return x.Key
	}
	return nil
}

type SenderCertificate_Certificate struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SenderE164    *string                `protobuf:"bytes,1,opt,name=senderE164" json:"senderE164,omitempty"`
	SenderUuid    *string                `protobuf:"bytes,6,opt,name=senderUuid" json:"senderUuid,omitempty"`
	SenderDevice  *uint32                `protobuf:"varint,2,opt,name=senderDevice" json:"senderDevice,omitempty"`
	Expires       *uint64                `protobuf:"fixed64,3,opt,name=expires" json:"expires,omitempty"`
	IdentityKey   []byte                 `protobuf:"bytes,4,opt,name=identityKey" json:"identityKey,omitempty"`
	Signer        *ServerCertificate     `protobuf:"bytes,5,opt,name=signer" json:"signer,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SenderCertificate_Certificate) ProtoMessage() {}

func (x *SenderCertificate_Certificate) ProtoReflect() protoreflect.Message {
	mi := &file_UnidentifiedDelivery_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 SenderCertificate_Certificate.ProtoReflect.Descriptor instead.
func (*SenderCertificate_Certificate) Descriptor() ([]byte, []int) {
	return file_UnidentifiedDelivery_proto_rawDescGZIP(), []int{1, 0}
}

func (x *SenderCertificate_Certificate) GetSenderE164() string {
	if x != nil && x.SenderE164 != nil {
		return *x.SenderE164
	}
	return ""
}

func (x *SenderCertificate_Certificate) GetSenderUuid() string {
	if x != nil && x.SenderUuid != nil {
		return *x.SenderUuid
	}
	return ""
}

func (x *SenderCertificate_Certificate) GetSenderDevice() uint32 {
	if x != nil && x.SenderDevice != nil {
		return *x.SenderDevice
	}
	return 0
}

func (x *SenderCertificate_Certificate) GetExpires() uint64 {
	if x != nil && x.Expires != nil {
		return *x.Expires
	}
	return 0
}

func (x *SenderCertificate_Certificate) GetIdentityKey() []byte {
	if x != nil {
		return x.IdentityKey
	}
	return nil
}

func (x *SenderCertificate_Certificate) GetSigner() *ServerCertificate {
	if x != nil {
		return x.Signer
	}
	return nil
}

type UnidentifiedSenderMessage_Message struct {
	state             protoimpl.MessageState                         `protogen:"open.v1"`
	Type              *UnidentifiedSenderMessage_Message_Type        `protobuf:"varint,1,opt,name=type,enum=signalservice.UnidentifiedSenderMessage_Message_Type" json:"type,omitempty"`
	SenderCertificate *SenderCertificate                             `protobuf:"bytes,2,opt,name=senderCertificate" json:"senderCertificate,omitempty"`
	Content           []byte                                         `protobuf:"bytes,3,opt,name=content" json:"content,omitempty"`
	ContentHint       *UnidentifiedSenderMessage_Message_ContentHint `protobuf:"varint,4,opt,name=contentHint,enum=signalservice.UnidentifiedSenderMessage_Message_ContentHint" json:"contentHint,omitempty"`
	GroupId           []byte                                         `protobuf:"bytes,5,opt,name=groupId" json:"groupId,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*UnidentifiedSenderMessage_Message) ProtoMessage() {}

func (x *UnidentifiedSenderMessage_Message) ProtoReflect() protoreflect.Message {
	mi := &file_UnidentifiedDelivery_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 UnidentifiedSenderMessage_Message.ProtoReflect.Descriptor instead.
func (*UnidentifiedSenderMessage_Message) Descriptor() ([]byte, []int) {
	return file_UnidentifiedDelivery_proto_rawDescGZIP(), []int{2, 0}
}

func (x *UnidentifiedSenderMessage_Message) GetType() UnidentifiedSenderMessage_Message_Type {
	if x != nil && x.Type != nil {
		return *x.Type
	}
	return UnidentifiedSenderMessage_Message_MESSAGE
}

func (x *UnidentifiedSenderMessage_Message) GetSenderCertificate() *SenderCertificate {
	if x != nil {
		return x.SenderCertificate
	}
	return nil
}

func (x *UnidentifiedSenderMessage_Message) GetContent() []byte {
	if x != nil {
		return x.Content
	}
	return nil
}

func (x *UnidentifiedSenderMessage_Message) GetContentHint() UnidentifiedSenderMessage_Message_ContentHint {
	if x != nil && x.ContentHint != nil {
		return *x.ContentHint
	}
	return UnidentifiedSenderMessage_Message_DEFAULT
}

func (x *UnidentifiedSenderMessage_Message) GetGroupId() []byte {
	if x != nil {
		return x.GroupId
	}
	return nil
}

var File_UnidentifiedDelivery_proto protoreflect.FileDescriptor

const file_UnidentifiedDelivery_proto_rawDesc = "" +
	"\n" +
	"\x1aUnidentifiedDelivery.proto\x12\rsignalservice\"\x84\x01\n" +
	"\x11ServerCertificate\x12 \n" +
	"\vcertificate\x18\x01 \x01(\fR\vcertificate\x12\x1c\n" +
	"\tsignature\x18\x02 \x01(\fR\tsignature\x1a/\n" +
	"\vCertificate\x12\x0e\n" +
	"\x02id\x18\x01 \x01(\rR\x02id\x12\x10\n" +
	"\x03key\x18\x02 \x01(\fR\x03key\"\xbd\x02\n" +
	"\x11SenderCertificate\x12 \n" +
	"\vcertificate\x18\x01 \x01(\fR\vcertificate\x12\x1c\n" +
	"\tsignature\x18\x02 \x01(\fR\tsignature\x1a\xe7\x01\n" +
	"\vCertificate\x12\x1e\n" +
	"\n" +
	"senderE164\x18\x01 \x01(\tR\n" +
	"senderE164\x12\x1e\n" +
	"\n" +
	"senderUuid\x18\x06 \x01(\tR\n" +
	"senderUuid\x12\"\n" +
	"\fsenderDevice\x18\x02 \x01(\rR\fsenderDevice\x12\x18\n" +
	"\aexpires\x18\x03 \x01(\x06R\aexpires\x12 \n" +
	"\videntityKey\x18\x04 \x01(\fR\videntityKey\x128\n" +
	"\x06signer\x18\x05 \x01(\v2 .signalservice.ServerCertificateR\x06signer\"\xe7\x04\n" +
	"\x19UnidentifiedSenderMessage\x12(\n" +
	"\x0fephemeralPublic\x18\x01 \x01(\fR\x0fephemeralPublic\x12(\n" +
	"\x0fencryptedStatic\x18\x02 \x01(\fR\x0fencryptedStatic\x12*\n" +
	"\x10encryptedMessage\x18\x03 \x01(\fR\x10encryptedMessage\x1a\xc9\x03\n" +
	"\aMessage\x12I\n" +
	"\x04type\x18\x01 \x01(\x0e25.signalservice.UnidentifiedSenderMessage.Message.TypeR\x04type\x12N\n" +
	"\x11senderCertificate\x18\x02 \x01(\v2 .signalservice.SenderCertificateR\x11senderCertificate\x12\x18\n" +
	"\acontent\x18\x03 \x01(\fR\acontent\x12^\n" +
	"\vcontentHint\x18\x04 \x01(\x0e2<.signalservice.UnidentifiedSenderMessage.Message.ContentHintR\vcontentHint\x12\x18\n" +
	"\agroupId\x18\x05 \x01(\fR\agroupId\"U\n" +
	"\x04Type\x12\v\n" +
	"\aMESSAGE\x10\x02\x12\x12\n" +
	"\x0ePREKEY_MESSAGE\x10\x03\x12\x15\n" +
	"\x11SENDERKEY_MESSAGE\x10\a\x12\x15\n" +
	"\x11PLAINTEXT_CONTENT\x10\b\"8\n" +
	"\vContentHint\x12\v\n" +
	"\aDEFAULT\x10\x00\x12\x0e\n" +
	"\n" +
	"RESENDABLE\x10\x01\x12\f\n" +
	"\bIMPLICIT\x10\x02B6\n" +
	"%org.whispersystems.libsignal.protocolB\rWhisperProtos"

var (
	file_UnidentifiedDelivery_proto_rawDescOnce sync.Once
	file_UnidentifiedDelivery_proto_rawDescData []byte
)

func file_UnidentifiedDelivery_proto_rawDescGZIP() []byte {
	file_UnidentifiedDelivery_proto_rawDescOnce.Do(func() {
		file_UnidentifiedDelivery_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_UnidentifiedDelivery_proto_rawDesc), len(file_UnidentifiedDelivery_proto_rawDesc)))
	})
	return file_UnidentifiedDelivery_proto_rawDescData
}

var file_UnidentifiedDelivery_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_UnidentifiedDelivery_proto_msgTypes = make([]protoimpl.MessageInfo, 6)
var file_UnidentifiedDelivery_proto_goTypes = []any{
	(UnidentifiedSenderMessage_Message_Type)(0),        // 0: signalservice.UnidentifiedSenderMessage.Message.Type
	(UnidentifiedSenderMessage_Message_ContentHint)(0), // 1: signalservice.UnidentifiedSenderMessage.Message.ContentHint
	(*ServerCertificate)(nil),                          // 2: signalservice.ServerCertificate
	(*SenderCertificate)(nil),                          // 3: signalservice.SenderCertificate
	(*UnidentifiedSenderMessage)(nil),                  // 4: signalservice.UnidentifiedSenderMessage
	(*ServerCertificate_Certificate)(nil),              // 5: signalservice.ServerCertificate.Certificate
	(*SenderCertificate_Certificate)(nil),              // 6: signalservice.SenderCertificate.Certificate
	(*UnidentifiedSenderMessage_Message)(nil),          // 7: signalservice.UnidentifiedSenderMessage.Message
}
var file_UnidentifiedDelivery_proto_depIdxs = []int32{
	2, // 0: signalservice.SenderCertificate.Certificate.signer:type_name -> signalservice.ServerCertificate
	0, // 1: signalservice.UnidentifiedSenderMessage.Message.type:type_name -> signalservice.UnidentifiedSenderMessage.Message.Type
	3, // 2: signalservice.UnidentifiedSenderMessage.Message.senderCertificate:type_name -> signalservice.SenderCertificate
	1, // 3: signalservice.UnidentifiedSenderMessage.Message.contentHint:type_name -> signalservice.UnidentifiedSenderMessage.Message.ContentHint
	4, // [4:4] is the sub-list for method output_type
	4, // [4:4] is the sub-list for method input_type
	4, // [4:4] is the sub-list for extension type_name
	4, // [4:4] is the sub-list for extension extendee
	0, // [0:4] is the sub-list for field type_name
}

func init() { file_UnidentifiedDelivery_proto_init() }
func file_UnidentifiedDelivery_proto_init() {
	if File_UnidentifiedDelivery_proto != nil {
		return
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_UnidentifiedDelivery_proto_rawDesc), len(file_UnidentifiedDelivery_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   6,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_UnidentifiedDelivery_proto_goTypes,
		DependencyIndexes: file_UnidentifiedDelivery_proto_depIdxs,
		EnumInfos:         file_UnidentifiedDelivery_proto_enumTypes,
		MessageInfos:      file_UnidentifiedDelivery_proto_msgTypes,
	}.Build()
	File_UnidentifiedDelivery_proto = out.File
	file_UnidentifiedDelivery_proto_goTypes = nil
	file_UnidentifiedDelivery_proto_depIdxs = nil
}