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

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v7.34.1
// source: org/signal/chat/messages.proto

package messages

import (
	common "go.mau.fi/mautrix-signal/pkg/signalmeow/protobuf/rpc/common"
	errors "go.mau.fi/mautrix-signal/pkg/signalmeow/protobuf/rpc/errors"
	_ "go.mau.fi/mautrix-signal/pkg/signalmeow/protobuf/rpc/require"
	_ "go.mau.fi/mautrix-signal/pkg/signalmeow/protobuf/rpc/tag"
	signalpb "go.mau.fi/mautrix-signal/pkg/signalmeow/protobuf/signalpb"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	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 SendMessageType int32

const (
	SendMessageType_UNSPECIFIED SendMessageType = 0
	// A double-ratchet message represents a "normal," "unsealed-sender" message
	// encrypted using the Double Ratchet within an established Signal session.
	SendMessageType_DOUBLE_RATCHET SendMessageType = 1
	// A prekey message begins a new Signal session. The `content` of a prekey
	// message is a superset of a double-ratchet message's `content` and
	// contains the sender's identity public key and information identifying the
	// pre-keys used in the message's ciphertext.
	SendMessageType_PREKEY_MESSAGE SendMessageType = 2
	// A plaintext message is used solely to convey encryption error receipts
	// and never contains encrypted message content. Encryption error receipts
	// must be delivered in plaintext because encryption/decryption of a prior
	// message failed and there is no reason to believe that
	// encryption/decryption of subsequent messages with the same key material
	// would succeed.
	//
	// Critically, plaintext messages never have "real" message content
	// generated by users. Plaintext messages include sender information.
	SendMessageType_PLAINTEXT_CONTENT SendMessageType = 3
	// An unidentified sender message is an encrypted message. No other
	// information about the type of the encrypted message is known to the server.
	//
	// Unidenitfied sender messages require an unidentified access token or a
	// group send endorsement token to prove the unidentified sender is authorized
	// to send messages to the destination.
	SendMessageType_UNIDENTIFIED_SENDER SendMessageType = 4
)

// Enum value maps for SendMessageType.
var (
	SendMessageType_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "DOUBLE_RATCHET",
		2: "PREKEY_MESSAGE",
		3: "PLAINTEXT_CONTENT",
		4: "UNIDENTIFIED_SENDER",
	}
	SendMessageType_value = map[string]int32{
		"UNSPECIFIED":         0,
		"DOUBLE_RATCHET":      1,
		"PREKEY_MESSAGE":      2,
		"PLAINTEXT_CONTENT":   3,
		"UNIDENTIFIED_SENDER": 4,
	}
)

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

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

func (SendMessageType) Descriptor() protoreflect.EnumDescriptor {
	return file_org_signal_chat_messages_proto_enumTypes[0].Descriptor()
}

func (SendMessageType) Type() protoreflect.EnumType {
	return &file_org_signal_chat_messages_proto_enumTypes[0]
}

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

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

type ChallengeRequired_ChallengeType int32

const (
	ChallengeRequired_UNSPECIFIED ChallengeRequired_ChallengeType = 0
	// A challenge that callers can fulfill by completing a captcha.
	ChallengeRequired_CAPTCHA ChallengeRequired_ChallengeType = 1
	// A challenge that callers can fulfill by supplying a token delivered via
	// push notification.
	ChallengeRequired_PUSH_CHALLENGE ChallengeRequired_ChallengeType = 2
)

// Enum value maps for ChallengeRequired_ChallengeType.
var (
	ChallengeRequired_ChallengeType_name = map[int32]string{
		0: "UNSPECIFIED",
		1: "CAPTCHA",
		2: "PUSH_CHALLENGE",
	}
	ChallengeRequired_ChallengeType_value = map[string]int32{
		"UNSPECIFIED":    0,
		"CAPTCHA":        1,
		"PUSH_CHALLENGE": 2,
	}
)

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

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

func (ChallengeRequired_ChallengeType) Descriptor() protoreflect.EnumDescriptor {
	return file_org_signal_chat_messages_proto_enumTypes[1].Descriptor()
}

func (ChallengeRequired_ChallengeType) Type() protoreflect.EnumType {
	return &file_org_signal_chat_messages_proto_enumTypes[1]
}

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

// Deprecated: Use ChallengeRequired_ChallengeType.Descriptor instead.
func (ChallengeRequired_ChallengeType) EnumDescriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{17, 0}
}

type GetMessagesRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Request:
	//
	//	*GetMessagesRequest_Options
	//	*GetMessagesRequest_ServerGuidAck
	Request       isGetMessagesRequest_Request `protobuf_oneof:"request"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetMessagesRequest) ProtoMessage() {}

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

func (x *GetMessagesRequest) GetRequest() isGetMessagesRequest_Request {
	if x != nil {
		return x.Request
	}
	return nil
}

func (x *GetMessagesRequest) GetOptions() *GetMessagesRequest_GetMessageOptions {
	if x != nil {
		if x, ok := x.Request.(*GetMessagesRequest_Options); ok {
			return x.Options
		}
	}
	return nil
}

func (x *GetMessagesRequest) GetServerGuidAck() []byte {
	if x != nil {
		if x, ok := x.Request.(*GetMessagesRequest_ServerGuidAck); ok {
			return x.ServerGuidAck
		}
	}
	return nil
}

type isGetMessagesRequest_Request interface {
	isGetMessagesRequest_Request()
}

type GetMessagesRequest_Options struct {
	// Configuration options for the message stream. Required for the first
	// request of the stream, forbidden on subsequent reqeusts.
	Options *GetMessagesRequest_GetMessageOptions `protobuf:"bytes,1,opt,name=options,proto3,oneof"`
}

type GetMessagesRequest_ServerGuidAck struct {
	// The server_guid of an envelope previously returned in a
	// GetMessagesResponse that has been successfully processed by the caller.
	// Forbidden on the first request of the stream, required on subsequent
	// requests.
	ServerGuidAck []byte `protobuf:"bytes,2,opt,name=server_guid_ack,json=serverGuidAck,proto3,oneof"`
}

func (*GetMessagesRequest_Options) isGetMessagesRequest_Request() {}

func (*GetMessagesRequest_ServerGuidAck) isGetMessagesRequest_Request() {}

// The reason why a GetMessages RPC is being closed by the server.
type GetMessagesStreamClosed struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Reason:
	//
	//	*GetMessagesStreamClosed_ConflictingStream
	Reason        isGetMessagesStreamClosed_Reason `protobuf_oneof:"reason"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetMessagesStreamClosed) ProtoMessage() {}

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

func (x *GetMessagesStreamClosed) GetReason() isGetMessagesStreamClosed_Reason {
	if x != nil {
		return x.Reason
	}
	return nil
}

func (x *GetMessagesStreamClosed) GetConflictingStream() *emptypb.Empty {
	if x != nil {
		if x, ok := x.Reason.(*GetMessagesStreamClosed_ConflictingStream); ok {
			return x.ConflictingStream
		}
	}
	return nil
}

type isGetMessagesStreamClosed_Reason interface {
	isGetMessagesStreamClosed_Reason()
}

type GetMessagesStreamClosed_ConflictingStream struct {
	// Another caller has opened a GetMessages stream for the same device.
	ConflictingStream *emptypb.Empty `protobuf:"bytes,1,opt,name=conflicting_stream,json=conflictingStream,proto3,oneof"`
}

func (*GetMessagesStreamClosed_ConflictingStream) isGetMessagesStreamClosed_Reason() {}

type GetMessagesResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Response:
	//
	//	*GetMessagesResponse_Envelope
	//	*GetMessagesResponse_QueueEmpty
	Response      isGetMessagesResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*GetMessagesResponse) ProtoMessage() {}

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

func (x *GetMessagesResponse) GetResponse() isGetMessagesResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *GetMessagesResponse) GetEnvelope() *signalpb.Envelope {
	if x != nil {
		if x, ok := x.Response.(*GetMessagesResponse_Envelope); ok {
			return x.Envelope
		}
	}
	return nil
}

func (x *GetMessagesResponse) GetQueueEmpty() *emptypb.Empty {
	if x != nil {
		if x, ok := x.Response.(*GetMessagesResponse_QueueEmpty); ok {
			return x.QueueEmpty
		}
	}
	return nil
}

type isGetMessagesResponse_Response interface {
	isGetMessagesResponse_Response()
}

type GetMessagesResponse_Envelope struct {
	// A message. On successful receipt of an envelope the caller should ack
	// the envelope by sending a GetMessagesRequest with the envelope's server
	// guid. Acks should only be sent for envelopes received on the currently
	// open RPC.
	Envelope *signalpb.Envelope `protobuf:"bytes,1,opt,name=envelope,proto3,oneof"`
}

type GetMessagesResponse_QueueEmpty struct {
	// An indicator that all outstanding messages for the device have been
	// drained and acked by the client. The stream will remain open and continue
	// to deliver newly arrived messages.
	QueueEmpty *emptypb.Empty `protobuf:"bytes,2,opt,name=queue_empty,json=queueEmpty,proto3,oneof"`
}

func (*GetMessagesResponse_Envelope) isGetMessagesResponse_Response() {}

func (*GetMessagesResponse_QueueEmpty) isGetMessagesResponse_Response() {}

type IndividualRecipientMessageBundle struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The time, in milliseconds since the epoch, at which this message was
	// originally sent from the perspective of the sender. Note that the maximum
	// allowable timestamp for JavaScript clients is less than Long.MAX_VALUE; see
	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#the_epoch_timestamps_and_invalid_date
	// for additional details and discussion.
	Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// A map of device IDs to individual messages. Generally, callers must include
	// one message for each device linked to the destination account. In cases of
	// "sync messages" where a sender is distributing information to other devices
	// linked to the sender's account, senders may omit a message for the sending
	// device.
	Messages      map[uint32]*IndividualRecipientMessageBundle_Message `protobuf:"bytes,2,rep,name=messages,proto3" json:"messages,omitempty" protobuf_key:"varint,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*IndividualRecipientMessageBundle) ProtoMessage() {}

func (x *IndividualRecipientMessageBundle) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_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 IndividualRecipientMessageBundle.ProtoReflect.Descriptor instead.
func (*IndividualRecipientMessageBundle) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{3}
}

func (x *IndividualRecipientMessageBundle) GetTimestamp() uint64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *IndividualRecipientMessageBundle) GetMessages() map[uint32]*IndividualRecipientMessageBundle_Message {
	if x != nil {
		return x.Messages
	}
	return nil
}

type SendAuthenticatedSenderMessageRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The service identifier of the account to which to deliver the message.
	Destination *common.ServiceIdentifier `protobuf:"bytes,1,opt,name=destination,proto3" json:"destination,omitempty"`
	// If true, this message will only be delivered to destination devices that
	// have an active message delivery channel with a Signal server.
	Ephemeral bool `protobuf:"varint,2,opt,name=ephemeral,proto3" json:"ephemeral,omitempty"`
	// Indicates whether this message is urgent and should trigger a high-priority
	// notification if the destination device does not have an active message
	// delivery channel with a Signal server
	Urgent bool `protobuf:"varint,3,opt,name=urgent,proto3" json:"urgent,omitempty"`
	// The messages to send to the destination account.
	Messages      *IndividualRecipientMessageBundle `protobuf:"bytes,4,opt,name=messages,proto3" json:"messages,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendAuthenticatedSenderMessageRequest) ProtoMessage() {}

func (x *SendAuthenticatedSenderMessageRequest) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_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 SendAuthenticatedSenderMessageRequest.ProtoReflect.Descriptor instead.
func (*SendAuthenticatedSenderMessageRequest) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{4}
}

func (x *SendAuthenticatedSenderMessageRequest) GetDestination() *common.ServiceIdentifier {
	if x != nil {
		return x.Destination
	}
	return nil
}

func (x *SendAuthenticatedSenderMessageRequest) GetEphemeral() bool {
	if x != nil {
		return x.Ephemeral
	}
	return false
}

func (x *SendAuthenticatedSenderMessageRequest) GetUrgent() bool {
	if x != nil {
		return x.Urgent
	}
	return false
}

func (x *SendAuthenticatedSenderMessageRequest) GetMessages() *IndividualRecipientMessageBundle {
	if x != nil {
		return x.Messages
	}
	return nil
}

type SendMessageAuthenticatedSenderResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The outcome of the message delivery
	//
	// Types that are valid to be assigned to Response:
	//
	//	*SendMessageAuthenticatedSenderResponse_Success
	//	*SendMessageAuthenticatedSenderResponse_MismatchedDevices
	//	*SendMessageAuthenticatedSenderResponse_ChallengeRequired
	//	*SendMessageAuthenticatedSenderResponse_DestinationNotFound
	Response      isSendMessageAuthenticatedSenderResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendMessageAuthenticatedSenderResponse) ProtoMessage() {}

func (x *SendMessageAuthenticatedSenderResponse) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_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 SendMessageAuthenticatedSenderResponse.ProtoReflect.Descriptor instead.
func (*SendMessageAuthenticatedSenderResponse) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{5}
}

func (x *SendMessageAuthenticatedSenderResponse) GetResponse() isSendMessageAuthenticatedSenderResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *SendMessageAuthenticatedSenderResponse) GetSuccess() *emptypb.Empty {
	if x != nil {
		if x, ok := x.Response.(*SendMessageAuthenticatedSenderResponse_Success); ok {
			return x.Success
		}
	}
	return nil
}

func (x *SendMessageAuthenticatedSenderResponse) GetMismatchedDevices() *MismatchedDevices {
	if x != nil {
		if x, ok := x.Response.(*SendMessageAuthenticatedSenderResponse_MismatchedDevices); ok {
			return x.MismatchedDevices
		}
	}
	return nil
}

func (x *SendMessageAuthenticatedSenderResponse) GetChallengeRequired() *ChallengeRequired {
	if x != nil {
		if x, ok := x.Response.(*SendMessageAuthenticatedSenderResponse_ChallengeRequired); ok {
			return x.ChallengeRequired
		}
	}
	return nil
}

func (x *SendMessageAuthenticatedSenderResponse) GetDestinationNotFound() *errors.NotFound {
	if x != nil {
		if x, ok := x.Response.(*SendMessageAuthenticatedSenderResponse_DestinationNotFound); ok {
			return x.DestinationNotFound
		}
	}
	return nil
}

type isSendMessageAuthenticatedSenderResponse_Response interface {
	isSendMessageAuthenticatedSenderResponse_Response()
}

type SendMessageAuthenticatedSenderResponse_Success struct {
	// The message was successfully delivered to all destination devices
	Success *emptypb.Empty `protobuf:"bytes,1,opt,name=success,proto3,oneof"`
}

type SendMessageAuthenticatedSenderResponse_MismatchedDevices struct {
	// A list of discrepancies between the destination devices identified in a
	// request to send a message and the devices that are actually linked to an
	// account.
	MismatchedDevices *MismatchedDevices `protobuf:"bytes,2,opt,name=mismatched_devices,json=mismatchedDevices,proto3,oneof"`
}

type SendMessageAuthenticatedSenderResponse_ChallengeRequired struct {
	// A description of a challenge callers must complete before sending
	// additional messages.
	ChallengeRequired *ChallengeRequired `protobuf:"bytes,3,opt,name=challenge_required,json=challengeRequired,proto3,oneof"`
}

type SendMessageAuthenticatedSenderResponse_DestinationNotFound struct {
	// The destination account did not exist
	DestinationNotFound *errors.NotFound `protobuf:"bytes,4,opt,name=destination_not_found,json=destinationNotFound,proto3,oneof"`
}

func (*SendMessageAuthenticatedSenderResponse_Success) isSendMessageAuthenticatedSenderResponse_Response() {
}

func (*SendMessageAuthenticatedSenderResponse_MismatchedDevices) isSendMessageAuthenticatedSenderResponse_Response() {
}

func (*SendMessageAuthenticatedSenderResponse_ChallengeRequired) isSendMessageAuthenticatedSenderResponse_Response() {
}

func (*SendMessageAuthenticatedSenderResponse_DestinationNotFound) isSendMessageAuthenticatedSenderResponse_Response() {
}

type SendSyncMessageRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Indicates whether this message is urgent and should trigger a high-priority
	// notification if the destination device does not have an active message
	// delivery channel with a Signal server
	Urgent bool `protobuf:"varint,1,opt,name=urgent,proto3" json:"urgent,omitempty"`
	// The messages to send to the destination account.
	Messages      *IndividualRecipientMessageBundle `protobuf:"bytes,2,opt,name=messages,proto3" json:"messages,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendSyncMessageRequest) ProtoMessage() {}

func (x *SendSyncMessageRequest) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_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 SendSyncMessageRequest.ProtoReflect.Descriptor instead.
func (*SendSyncMessageRequest) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{6}
}

func (x *SendSyncMessageRequest) GetUrgent() bool {
	if x != nil {
		return x.Urgent
	}
	return false
}

func (x *SendSyncMessageRequest) GetMessages() *IndividualRecipientMessageBundle {
	if x != nil {
		return x.Messages
	}
	return nil
}

type SendSealedSenderMessageRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The service identifier of the account to which to deliver the message.
	Destination *common.ServiceIdentifier `protobuf:"bytes,1,opt,name=destination,proto3" json:"destination,omitempty"`
	// If true, this message will only be delivered to destination devices that
	// have an active message delivery channel with a Signal server.
	Ephemeral bool `protobuf:"varint,2,opt,name=ephemeral,proto3" json:"ephemeral,omitempty"`
	// Indicates whether this message is urgent and should trigger a high-priority
	// notification if the destination device does not have an active message
	// delivery channel with a Signal server
	Urgent bool `protobuf:"varint,3,opt,name=urgent,proto3" json:"urgent,omitempty"`
	// The messages to send to the destination account.
	Messages *IndividualRecipientMessageBundle `protobuf:"bytes,4,opt,name=messages,proto3" json:"messages,omitempty"`
	// A means to authorize the request.
	//
	// Types that are valid to be assigned to Authorization:
	//
	//	*SendSealedSenderMessageRequest_UnidentifiedAccessKey
	//	*SendSealedSenderMessageRequest_GroupSendToken
	//	*SendSealedSenderMessageRequest_UnrestrictedAccess
	Authorization isSendSealedSenderMessageRequest_Authorization `protobuf_oneof:"authorization"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendSealedSenderMessageRequest) ProtoMessage() {}

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

func (x *SendSealedSenderMessageRequest) GetDestination() *common.ServiceIdentifier {
	if x != nil {
		return x.Destination
	}
	return nil
}

func (x *SendSealedSenderMessageRequest) GetEphemeral() bool {
	if x != nil {
		return x.Ephemeral
	}
	return false
}

func (x *SendSealedSenderMessageRequest) GetUrgent() bool {
	if x != nil {
		return x.Urgent
	}
	return false
}

func (x *SendSealedSenderMessageRequest) GetMessages() *IndividualRecipientMessageBundle {
	if x != nil {
		return x.Messages
	}
	return nil
}

func (x *SendSealedSenderMessageRequest) GetAuthorization() isSendSealedSenderMessageRequest_Authorization {
	if x != nil {
		return x.Authorization
	}
	return nil
}

func (x *SendSealedSenderMessageRequest) GetUnidentifiedAccessKey() []byte {
	if x != nil {
		if x, ok := x.Authorization.(*SendSealedSenderMessageRequest_UnidentifiedAccessKey); ok {
			return x.UnidentifiedAccessKey
		}
	}
	return nil
}

func (x *SendSealedSenderMessageRequest) GetGroupSendToken() []byte {
	if x != nil {
		if x, ok := x.Authorization.(*SendSealedSenderMessageRequest_GroupSendToken); ok {
			return x.GroupSendToken
		}
	}
	return nil
}

func (x *SendSealedSenderMessageRequest) GetUnrestrictedAccess() *emptypb.Empty {
	if x != nil {
		if x, ok := x.Authorization.(*SendSealedSenderMessageRequest_UnrestrictedAccess); ok {
			return x.UnrestrictedAccess
		}
	}
	return nil
}

type isSendSealedSenderMessageRequest_Authorization interface {
	isSendSealedSenderMessageRequest_Authorization()
}

type SendSealedSenderMessageRequest_UnidentifiedAccessKey struct {
	// The unidentified access key (UAK) for the destination account.
	UnidentifiedAccessKey []byte `protobuf:"bytes,5,opt,name=unidentified_access_key,json=unidentifiedAccessKey,proto3,oneof"`
}

type SendSealedSenderMessageRequest_GroupSendToken struct {
	// A group send endorsement token for the destination account.
	GroupSendToken []byte `protobuf:"bytes,6,opt,name=group_send_token,json=groupSendToken,proto3,oneof"`
}

type SendSealedSenderMessageRequest_UnrestrictedAccess struct {
	// The destination account allows unrestricted unidentified access
	UnrestrictedAccess *emptypb.Empty `protobuf:"bytes,7,opt,name=unrestricted_access,json=unrestrictedAccess,proto3,oneof"`
}

func (*SendSealedSenderMessageRequest_UnidentifiedAccessKey) isSendSealedSenderMessageRequest_Authorization() {
}

func (*SendSealedSenderMessageRequest_GroupSendToken) isSendSealedSenderMessageRequest_Authorization() {
}

func (*SendSealedSenderMessageRequest_UnrestrictedAccess) isSendSealedSenderMessageRequest_Authorization() {
}

type SendStoryMessageRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The service identifier of the account to which to deliver the message.
	Destination *common.ServiceIdentifier `protobuf:"bytes,1,opt,name=destination,proto3" json:"destination,omitempty"`
	// Indicates whether this message is urgent and should trigger a high-priority
	// notification if the destination device does not have an active message
	// delivery channel with a Signal server
	Urgent bool `protobuf:"varint,2,opt,name=urgent,proto3" json:"urgent,omitempty"`
	// The messages to send to the destination account.
	Messages      *IndividualRecipientMessageBundle `protobuf:"bytes,3,opt,name=messages,proto3" json:"messages,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendStoryMessageRequest) ProtoMessage() {}

func (x *SendStoryMessageRequest) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_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 SendStoryMessageRequest.ProtoReflect.Descriptor instead.
func (*SendStoryMessageRequest) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{8}
}

func (x *SendStoryMessageRequest) GetDestination() *common.ServiceIdentifier {
	if x != nil {
		return x.Destination
	}
	return nil
}

func (x *SendStoryMessageRequest) GetUrgent() bool {
	if x != nil {
		return x.Urgent
	}
	return false
}

func (x *SendStoryMessageRequest) GetMessages() *IndividualRecipientMessageBundle {
	if x != nil {
		return x.Messages
	}
	return nil
}

type SendMessageResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The outcome of the message delivery
	//
	// Types that are valid to be assigned to Response:
	//
	//	*SendMessageResponse_Success
	//	*SendMessageResponse_MismatchedDevices
	//	*SendMessageResponse_FailedUnidentifiedAuthorization
	//	*SendMessageResponse_DestinationNotFound
	Response      isSendMessageResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SendMessageResponse) ProtoMessage() {}

func (x *SendMessageResponse) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_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 SendMessageResponse.ProtoReflect.Descriptor instead.
func (*SendMessageResponse) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{9}
}

func (x *SendMessageResponse) GetResponse() isSendMessageResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *SendMessageResponse) GetSuccess() *emptypb.Empty {
	if x != nil {
		if x, ok := x.Response.(*SendMessageResponse_Success); ok {
			return x.Success
		}
	}
	return nil
}

func (x *SendMessageResponse) GetMismatchedDevices() *MismatchedDevices {
	if x != nil {
		if x, ok := x.Response.(*SendMessageResponse_MismatchedDevices); ok {
			return x.MismatchedDevices
		}
	}
	return nil
}

func (x *SendMessageResponse) GetFailedUnidentifiedAuthorization() *errors.FailedUnidentifiedAuthorization {
	if x != nil {
		if x, ok := x.Response.(*SendMessageResponse_FailedUnidentifiedAuthorization); ok {
			return x.FailedUnidentifiedAuthorization
		}
	}
	return nil
}

func (x *SendMessageResponse) GetDestinationNotFound() *errors.NotFound {
	if x != nil {
		if x, ok := x.Response.(*SendMessageResponse_DestinationNotFound); ok {
			return x.DestinationNotFound
		}
	}
	return nil
}

type isSendMessageResponse_Response interface {
	isSendMessageResponse_Response()
}

type SendMessageResponse_Success struct {
	// The message was successfully delivered to all destination devices
	Success *emptypb.Empty `protobuf:"bytes,1,opt,name=success,proto3,oneof"`
}

type SendMessageResponse_MismatchedDevices struct {
	// A list of discrepancies between the destination devices identified in a
	// request to send a message and the devices that are actually linked to an
	// account.
	MismatchedDevices *MismatchedDevices `protobuf:"bytes,2,opt,name=mismatched_devices,json=mismatchedDevices,proto3,oneof"`
}

type SendMessageResponse_FailedUnidentifiedAuthorization struct {
	// The provided unidentified authorization credential was invalid
	FailedUnidentifiedAuthorization *errors.FailedUnidentifiedAuthorization `protobuf:"bytes,3,opt,name=failed_unidentified_authorization,json=failedUnidentifiedAuthorization,proto3,oneof"`
}

type SendMessageResponse_DestinationNotFound struct {
	// The destination account did not exist
	DestinationNotFound *errors.NotFound `protobuf:"bytes,4,opt,name=destination_not_found,json=destinationNotFound,proto3,oneof"`
}

func (*SendMessageResponse_Success) isSendMessageResponse_Response() {}

func (*SendMessageResponse_MismatchedDevices) isSendMessageResponse_Response() {}

func (*SendMessageResponse_FailedUnidentifiedAuthorization) isSendMessageResponse_Response() {}

func (*SendMessageResponse_DestinationNotFound) isSendMessageResponse_Response() {}

type MultiRecipientMessage struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The time, in milliseconds since the epoch, at which this message was
	// originally sent from the perspective of the sender. Note that the maximum
	// allowable timestamp for JavaScript clients is less than Long.MAX_VALUE; see
	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date#the_epoch_timestamps_and_invalid_date
	// for additional details and discussion.
	Timestamp uint64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// The serialized multi-recipient message payload.
	Payload       []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` // 256 KiB payload + (5000 * 100) of overhead
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MultiRecipientMessage) Reset() {
	*x = MultiRecipientMessage{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MultiRecipientMessage) ProtoMessage() {}

func (x *MultiRecipientMessage) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_proto_msgTypes[10]
	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 MultiRecipientMessage.ProtoReflect.Descriptor instead.
func (*MultiRecipientMessage) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{10}
}

func (x *MultiRecipientMessage) GetTimestamp() uint64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *MultiRecipientMessage) GetPayload() []byte {
	if x != nil {
		return x.Payload
	}
	return nil
}

type SendMultiRecipientMessageRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// If true, this message will only be delivered to destination devices that
	// have an active message delivery channel with a Signal server.
	Ephemeral bool `protobuf:"varint,1,opt,name=ephemeral,proto3" json:"ephemeral,omitempty"`
	// Indicates whether this message is urgent and should trigger a high-priority
	// notification if the destination device does not have an active message
	// delivery channel with a Signal server
	Urgent bool `protobuf:"varint,2,opt,name=urgent,proto3" json:"urgent,omitempty"`
	// The multi-recipient message to send to all destination accounts and
	// devices.
	Message *MultiRecipientMessage `protobuf:"bytes,3,opt,name=message,proto3" json:"message,omitempty"`
	// A group send endorsement token for the destination account.
	GroupSendToken []byte `protobuf:"bytes,4,opt,name=group_send_token,json=groupSendToken,proto3" json:"group_send_token,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

func (x *SendMultiRecipientMessageRequest) Reset() {
	*x = SendMultiRecipientMessageRequest{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SendMultiRecipientMessageRequest) ProtoMessage() {}

func (x *SendMultiRecipientMessageRequest) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_proto_msgTypes[11]
	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 SendMultiRecipientMessageRequest.ProtoReflect.Descriptor instead.
func (*SendMultiRecipientMessageRequest) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{11}
}

func (x *SendMultiRecipientMessageRequest) GetEphemeral() bool {
	if x != nil {
		return x.Ephemeral
	}
	return false
}

func (x *SendMultiRecipientMessageRequest) GetUrgent() bool {
	if x != nil {
		return x.Urgent
	}
	return false
}

func (x *SendMultiRecipientMessageRequest) GetMessage() *MultiRecipientMessage {
	if x != nil {
		return x.Message
	}
	return nil
}

func (x *SendMultiRecipientMessageRequest) GetGroupSendToken() []byte {
	if x != nil {
		return x.GroupSendToken
	}
	return nil
}

type SendMultiRecipientStoryRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Indicates whether this message is urgent and should trigger a high-priority
	// notification if the destination device does not have an active message
	// delivery channel with a Signal server
	Urgent bool `protobuf:"varint,1,opt,name=urgent,proto3" json:"urgent,omitempty"`
	// The multi-recipient story message to send to all destination accounts and
	// devices.
	Message       *MultiRecipientMessage `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SendMultiRecipientStoryRequest) Reset() {
	*x = SendMultiRecipientStoryRequest{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SendMultiRecipientStoryRequest) ProtoMessage() {}

func (x *SendMultiRecipientStoryRequest) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_proto_msgTypes[12]
	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 SendMultiRecipientStoryRequest.ProtoReflect.Descriptor instead.
func (*SendMultiRecipientStoryRequest) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{12}
}

func (x *SendMultiRecipientStoryRequest) GetUrgent() bool {
	if x != nil {
		return x.Urgent
	}
	return false
}

func (x *SendMultiRecipientStoryRequest) GetMessage() *MultiRecipientMessage {
	if x != nil {
		return x.Message
	}
	return nil
}

type MultiRecipientSuccess struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A list of destination service identifiers that could not be resolved to
	// registered Signal accounts. The  message in the original request was sent
	// to all service identifiers/devices in the original request except for the
	// destination devices associated with the service identifiers in this list.
	UnresolvedRecipients []*common.ServiceIdentifier `protobuf:"bytes,1,rep,name=unresolved_recipients,json=unresolvedRecipients,proto3" json:"unresolved_recipients,omitempty"`
	unknownFields        protoimpl.UnknownFields
	sizeCache            protoimpl.SizeCache
}

func (x *MultiRecipientSuccess) Reset() {
	*x = MultiRecipientSuccess{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MultiRecipientSuccess) ProtoMessage() {}

func (x *MultiRecipientSuccess) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_proto_msgTypes[13]
	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 MultiRecipientSuccess.ProtoReflect.Descriptor instead.
func (*MultiRecipientSuccess) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{13}
}

func (x *MultiRecipientSuccess) GetUnresolvedRecipients() []*common.ServiceIdentifier {
	if x != nil {
		return x.UnresolvedRecipients
	}
	return nil
}

type SendMultiRecipientMessageResponse struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The outcome of the message delivery
	//
	// Types that are valid to be assigned to Response:
	//
	//	*SendMultiRecipientMessageResponse_Success
	//	*SendMultiRecipientMessageResponse_MismatchedDevices
	//	*SendMultiRecipientMessageResponse_FailedUnidentifiedAuthorization
	Response      isSendMultiRecipientMessageResponse_Response `protobuf_oneof:"response"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *SendMultiRecipientMessageResponse) Reset() {
	*x = SendMultiRecipientMessageResponse{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[14]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*SendMultiRecipientMessageResponse) ProtoMessage() {}

func (x *SendMultiRecipientMessageResponse) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_proto_msgTypes[14]
	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 SendMultiRecipientMessageResponse.ProtoReflect.Descriptor instead.
func (*SendMultiRecipientMessageResponse) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{14}
}

func (x *SendMultiRecipientMessageResponse) GetResponse() isSendMultiRecipientMessageResponse_Response {
	if x != nil {
		return x.Response
	}
	return nil
}

func (x *SendMultiRecipientMessageResponse) GetSuccess() *MultiRecipientSuccess {
	if x != nil {
		if x, ok := x.Response.(*SendMultiRecipientMessageResponse_Success); ok {
			return x.Success
		}
	}
	return nil
}

func (x *SendMultiRecipientMessageResponse) GetMismatchedDevices() *MultiRecipientMismatchedDevices {
	if x != nil {
		if x, ok := x.Response.(*SendMultiRecipientMessageResponse_MismatchedDevices); ok {
			return x.MismatchedDevices
		}
	}
	return nil
}

func (x *SendMultiRecipientMessageResponse) GetFailedUnidentifiedAuthorization() *errors.FailedUnidentifiedAuthorization {
	if x != nil {
		if x, ok := x.Response.(*SendMultiRecipientMessageResponse_FailedUnidentifiedAuthorization); ok {
			return x.FailedUnidentifiedAuthorization
		}
	}
	return nil
}

type isSendMultiRecipientMessageResponse_Response interface {
	isSendMultiRecipientMessageResponse_Response()
}

type SendMultiRecipientMessageResponse_Success struct {
	// The message was sent to at least some of the destination accounts/devices
	// identified in the original request.
	Success *MultiRecipientSuccess `protobuf:"bytes,1,opt,name=success,proto3,oneof"`
}

type SendMultiRecipientMessageResponse_MismatchedDevices struct {
	// A list of sets of discrepancies between the destination devices
	// identified in a request to send a message and the devices that are
	// actually linked to a destination account.
	MismatchedDevices *MultiRecipientMismatchedDevices `protobuf:"bytes,2,opt,name=mismatched_devices,json=mismatchedDevices,proto3,oneof"`
}

type SendMultiRecipientMessageResponse_FailedUnidentifiedAuthorization struct {
	// The provided unidentified authorization credential was invalid
	FailedUnidentifiedAuthorization *errors.FailedUnidentifiedAuthorization `protobuf:"bytes,3,opt,name=failed_unidentified_authorization,json=failedUnidentifiedAuthorization,proto3,oneof"`
}

func (*SendMultiRecipientMessageResponse_Success) isSendMultiRecipientMessageResponse_Response() {}

func (*SendMultiRecipientMessageResponse_MismatchedDevices) isSendMultiRecipientMessageResponse_Response() {
}

func (*SendMultiRecipientMessageResponse_FailedUnidentifiedAuthorization) isSendMultiRecipientMessageResponse_Response() {
}

type MismatchedDevices struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The service identifier to which the devices named in this object are
	// linked.
	ServiceIdentifier *common.ServiceIdentifier `protobuf:"bytes,1,opt,name=service_identifier,json=serviceIdentifier,proto3" json:"service_identifier,omitempty"`
	// A list of device IDs that are linked to the destination account, but were
	// not included in the collection of messages bound for the destination
	// account.
	MissingDevices []uint32 `protobuf:"varint,2,rep,packed,name=missing_devices,json=missingDevices,proto3" json:"missing_devices,omitempty"`
	// A list of device IDs that were included in the collection of messages bound
	// for the destination account, but are not currently linked to the
	// destination account.
	ExtraDevices []uint32 `protobuf:"varint,3,rep,packed,name=extra_devices,json=extraDevices,proto3" json:"extra_devices,omitempty"`
	// A list of device IDs that present in the collection of messages bound for
	// the destination account and are linked to the destination account, but have
	// a different registration ID than the registration ID presented by the
	// sender (indicating that the destination device has likely been replaced by
	// another device).
	StaleDevices  []uint32 `protobuf:"varint,4,rep,packed,name=stale_devices,json=staleDevices,proto3" json:"stale_devices,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *MismatchedDevices) Reset() {
	*x = MismatchedDevices{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[15]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MismatchedDevices) ProtoMessage() {}

func (x *MismatchedDevices) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_proto_msgTypes[15]
	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 MismatchedDevices.ProtoReflect.Descriptor instead.
func (*MismatchedDevices) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{15}
}

func (x *MismatchedDevices) GetServiceIdentifier() *common.ServiceIdentifier {
	if x != nil {
		return x.ServiceIdentifier
	}
	return nil
}

func (x *MismatchedDevices) GetMissingDevices() []uint32 {
	if x != nil {
		return x.MissingDevices
	}
	return nil
}

func (x *MismatchedDevices) GetExtraDevices() []uint32 {
	if x != nil {
		return x.ExtraDevices
	}
	return nil
}

func (x *MismatchedDevices) GetStaleDevices() []uint32 {
	if x != nil {
		return x.StaleDevices
	}
	return nil
}

type MultiRecipientMismatchedDevices struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A list of sets of discrepancies between the destination devices identified
	// in a request to send a message and the devices that are actually linked to
	// a destination account.
	MismatchedDevices []*MismatchedDevices `protobuf:"bytes,1,rep,name=mismatched_devices,json=mismatchedDevices,proto3" json:"mismatched_devices,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *MultiRecipientMismatchedDevices) Reset() {
	*x = MultiRecipientMismatchedDevices{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*MultiRecipientMismatchedDevices) ProtoMessage() {}

func (x *MultiRecipientMismatchedDevices) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_proto_msgTypes[16]
	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 MultiRecipientMismatchedDevices.ProtoReflect.Descriptor instead.
func (*MultiRecipientMismatchedDevices) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{16}
}

func (x *MultiRecipientMismatchedDevices) GetMismatchedDevices() []*MismatchedDevices {
	if x != nil {
		return x.MismatchedDevices
	}
	return nil
}

type ChallengeRequired struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// An opaque token identifying this challenge request. Clients must generally
	// submit this token when submitting a challenge response.
	Token string `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	// A list of challenge types callers may choose to complete to resolve the
	// challenge requirement. May be empty, in which case callers cannot resolve
	// the challenge by any means other than waiting.
	ChallengeOptions []ChallengeRequired_ChallengeType `protobuf:"varint,2,rep,packed,name=challenge_options,json=challengeOptions,proto3,enum=org.signal.chat.messages.ChallengeRequired_ChallengeType" json:"challenge_options,omitempty"`
	// A duration (in seconds) after which the challenge requirement may be
	// resolved by simply waiting. May not be set if the challenge cannot be
	// resolved by waiting.
	RetryAfterSeconds *uint64 `protobuf:"varint,3,opt,name=retry_after_seconds,json=retryAfterSeconds,proto3,oneof" json:"retry_after_seconds,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

func (x *ChallengeRequired) Reset() {
	*x = ChallengeRequired{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*ChallengeRequired) ProtoMessage() {}

func (x *ChallengeRequired) ProtoReflect() protoreflect.Message {
	mi := &file_org_signal_chat_messages_proto_msgTypes[17]
	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 ChallengeRequired.ProtoReflect.Descriptor instead.
func (*ChallengeRequired) Descriptor() ([]byte, []int) {
	return file_org_signal_chat_messages_proto_rawDescGZIP(), []int{17}
}

func (x *ChallengeRequired) GetToken() string {
	if x != nil {
		return x.Token
	}
	return ""
}

func (x *ChallengeRequired) GetChallengeOptions() []ChallengeRequired_ChallengeType {
	if x != nil {
		return x.ChallengeOptions
	}
	return nil
}

func (x *ChallengeRequired) GetRetryAfterSeconds() uint64 {
	if x != nil && x.RetryAfterSeconds != nil {
		return *x.RetryAfterSeconds
	}
	return 0
}

type GetMessagesRequest_GetMessageOptions struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// If present and true, the server will not deliver any messages with the
	// story flag set. This flag may only be set on the first GetMessagesRequest
	// sent from the client to the server in an RPC stream.
	DropStories   bool `protobuf:"varint,1,opt,name=drop_stories,json=dropStories,proto3" json:"drop_stories,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *GetMessagesRequest_GetMessageOptions) Reset() {
	*x = GetMessagesRequest_GetMessageOptions{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*GetMessagesRequest_GetMessageOptions) ProtoMessage() {}

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

func (x *GetMessagesRequest_GetMessageOptions) GetDropStories() bool {
	if x != nil {
		return x.DropStories
	}
	return false
}

// A message for an individual device linked to a destination account.
type IndividualRecipientMessageBundle_Message struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The registration ID for the destination device.
	RegistrationId uint32 `protobuf:"varint,1,opt,name=registration_id,json=registrationId,proto3" json:"registration_id,omitempty"`
	// The content of the message to deliver to the destination device.
	Payload []byte `protobuf:"bytes,2,opt,name=payload,proto3" json:"payload,omitempty"` // 256 KiB
	// The message type of the message. If this message is part of an
	// unidentified send, this must be UNIDENTIFIED_SENDER
	Type          SendMessageType `protobuf:"varint,3,opt,name=type,proto3,enum=org.signal.chat.messages.SendMessageType" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *IndividualRecipientMessageBundle_Message) Reset() {
	*x = IndividualRecipientMessageBundle_Message{}
	mi := &file_org_signal_chat_messages_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*IndividualRecipientMessageBundle_Message) ProtoMessage() {}

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

func (x *IndividualRecipientMessageBundle_Message) GetRegistrationId() uint32 {
	if x != nil {
		return x.RegistrationId
	}
	return 0
}

func (x *IndividualRecipientMessageBundle_Message) GetPayload() []byte {
	if x != nil {
		return x.Payload
	}
	return nil
}

func (x *IndividualRecipientMessageBundle_Message) GetType() SendMessageType {
	if x != nil {
		return x.Type
	}
	return SendMessageType_UNSPECIFIED
}

var File_org_signal_chat_messages_proto protoreflect.FileDescriptor

const file_org_signal_chat_messages_proto_rawDesc = "" +
	"\n" +
	"\x1eorg/signal/chat/messages.proto\x12\x18org.signal.chat.messages\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1corg/signal/chat/common.proto\x1a\x1dorg/signal/chat/require.proto\x1a\x1corg/signal/chat/errors.proto\x1a\x19org/signal/chat/tag.proto\x1a\x1csignalpb/SignalService.proto\"\xdd\x01\n" +
	"\x12GetMessagesRequest\x12Z\n" +
	"\aoptions\x18\x01 \x01(\v2>.org.signal.chat.messages.GetMessagesRequest.GetMessageOptionsH\x00R\aoptions\x12(\n" +
	"\x0fserver_guid_ack\x18\x02 \x01(\fH\x00R\rserverGuidAck\x1a6\n" +
	"\x11GetMessageOptions\x12!\n" +
	"\fdrop_stories\x18\x01 \x01(\bR\vdropStoriesB\t\n" +
	"\arequest\"l\n" +
	"\x17GetMessagesStreamClosed\x12G\n" +
	"\x12conflicting_stream\x18\x01 \x01(\v2\x16.google.protobuf.EmptyH\x00R\x11conflictingStreamB\b\n" +
	"\x06reason\"\x93\x01\n" +
	"\x13GetMessagesResponse\x125\n" +
	"\benvelope\x18\x01 \x01(\v2\x17.signalservice.EnvelopeH\x00R\benvelope\x129\n" +
	"\vqueue_empty\x18\x02 \x01(\v2\x16.google.protobuf.EmptyH\x00R\n" +
	"queueEmptyB\n" +
	"\n" +
	"\bresponse\"\xe1\x03\n" +
	" IndividualRecipientMessageBundle\x12-\n" +
	"\ttimestamp\x18\x01 \x01(\x04B\x0f\xb2\x97\"\v\b\x01\x10\x80\x80\xf0\x96\x8c\xc1\xac\x0fR\ttimestamp\x12j\n" +
	"\bmessages\x18\x02 \x03(\v2H.org.signal.chat.messages.IndividualRecipientMessageBundle.MessagesEntryB\x04\x88\x97\"\x01R\bmessages\x1a\xa0\x01\n" +
	"\aMessage\x120\n" +
	"\x0fregistration_id\x18\x01 \x01(\rB\a\xb2\x97\"\x03\x10\xff\x7fR\x0eregistrationId\x12$\n" +
	"\apayload\x18\x02 \x01(\fB\n" +
	"\x9a\x97\"\x06\b\x01\x10\x80\x80\x10R\apayload\x12=\n" +
	"\x04type\x18\x03 \x01(\x0e2).org.signal.chat.messages.SendMessageTypeR\x04type\x1a\x7f\n" +
	"\rMessagesEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\rR\x03key\x12X\n" +
	"\x05value\x18\x02 \x01(\v2B.org.signal.chat.messages.IndividualRecipientMessageBundle.MessageR\x05value:\x028\x01\"\x82\x02\n" +
	"%SendAuthenticatedSenderMessageRequest\x12K\n" +
	"\vdestination\x18\x01 \x01(\v2).org.signal.chat.common.ServiceIdentifierR\vdestination\x12\x1c\n" +
	"\tephemeral\x18\x02 \x01(\bR\tephemeral\x12\x16\n" +
	"\x06urgent\x18\x03 \x01(\bR\x06urgent\x12V\n" +
	"\bmessages\x18\x04 \x01(\v2:.org.signal.chat.messages.IndividualRecipientMessageBundleR\bmessages\"\xc7\x03\n" +
	"&SendMessageAuthenticatedSenderResponse\x122\n" +
	"\asuccess\x18\x01 \x01(\v2\x16.google.protobuf.EmptyH\x00R\asuccess\x12t\n" +
	"\x12mismatched_devices\x18\x02 \x01(\v2+.org.signal.chat.messages.MismatchedDevicesB\x16\xc2\xd5\"\x12mismatched_devicesH\x00R\x11mismatchedDevices\x12t\n" +
	"\x12challenge_required\x18\x03 \x01(\v2+.org.signal.chat.messages.ChallengeRequiredB\x16\xc2\xd5\"\x12challenge_requiredH\x00R\x11challengeRequired\x12q\n" +
	"\x15destination_not_found\x18\x04 \x01(\v2 .org.signal.chat.errors.NotFoundB\x19\xc2\xd5\"\x15destination_not_foundH\x00R\x13destinationNotFoundB\n" +
	"\n" +
	"\bresponse\"\x88\x01\n" +
	"\x16SendSyncMessageRequest\x12\x16\n" +
	"\x06urgent\x18\x01 \x01(\bR\x06urgent\x12V\n" +
	"\bmessages\x18\x02 \x01(\v2:.org.signal.chat.messages.IndividualRecipientMessageBundleR\bmessages\"\xc4\x03\n" +
	"\x1eSendSealedSenderMessageRequest\x12K\n" +
	"\vdestination\x18\x01 \x01(\v2).org.signal.chat.common.ServiceIdentifierR\vdestination\x12\x1c\n" +
	"\tephemeral\x18\x02 \x01(\bR\tephemeral\x12\x16\n" +
	"\x06urgent\x18\x03 \x01(\bR\x06urgent\x12V\n" +
	"\bmessages\x18\x04 \x01(\v2:.org.signal.chat.messages.IndividualRecipientMessageBundleR\bmessages\x12?\n" +
	"\x17unidentified_access_key\x18\x05 \x01(\fB\x05\xa2\x97\"\x01\x10H\x00R\x15unidentifiedAccessKey\x12*\n" +
	"\x10group_send_token\x18\x06 \x01(\fH\x00R\x0egroupSendToken\x12I\n" +
	"\x13unrestricted_access\x18\a \x01(\v2\x16.google.protobuf.EmptyH\x00R\x12unrestrictedAccessB\x0f\n" +
	"\rauthorization\"\xd6\x01\n" +
	"\x17SendStoryMessageRequest\x12K\n" +
	"\vdestination\x18\x01 \x01(\v2).org.signal.chat.common.ServiceIdentifierR\vdestination\x12\x16\n" +
	"\x06urgent\x18\x02 \x01(\bR\x06urgent\x12V\n" +
	"\bmessages\x18\x03 \x01(\v2:.org.signal.chat.messages.IndividualRecipientMessageBundleR\bmessages\"\xed\x03\n" +
	"\x13SendMessageResponse\x122\n" +
	"\asuccess\x18\x01 \x01(\v2\x16.google.protobuf.EmptyH\x00R\asuccess\x12t\n" +
	"\x12mismatched_devices\x18\x02 \x01(\v2+.org.signal.chat.messages.MismatchedDevicesB\x16\xc2\xd5\"\x12mismatched_devicesH\x00R\x11mismatchedDevices\x12\xac\x01\n" +
	"!failed_unidentified_authorization\x18\x03 \x01(\v27.org.signal.chat.errors.FailedUnidentifiedAuthorizationB%\xc2\xd5\"!failed_unidentified_authorizationH\x00R\x1ffailedUnidentifiedAuthorization\x12q\n" +
	"\x15destination_not_found\x18\x04 \x01(\v2 .org.signal.chat.errors.NotFoundB\x19\xc2\xd5\"\x15destination_not_foundH\x00R\x13destinationNotFoundB\n" +
	"\n" +
	"\bresponse\"j\n" +
	"\x15MultiRecipientMessage\x12-\n" +
	"\ttimestamp\x18\x01 \x01(\x04B\x0f\xb2\x97\"\v\b\x01\x10\x80\x80\xf0\x96\x8c\xc1\xac\x0fR\ttimestamp\x12\"\n" +
	"\apayload\x18\x02 \x01(\fB\b\x9a\x97\"\x04\x10\xa0\xc2.R\apayload\"\xd3\x01\n" +
	" SendMultiRecipientMessageRequest\x12\x1c\n" +
	"\tephemeral\x18\x01 \x01(\bR\tephemeral\x12\x16\n" +
	"\x06urgent\x18\x02 \x01(\bR\x06urgent\x12I\n" +
	"\amessage\x18\x03 \x01(\v2/.org.signal.chat.messages.MultiRecipientMessageR\amessage\x12.\n" +
	"\x10group_send_token\x18\x04 \x01(\fB\x04\x88\x97\"\x01R\x0egroupSendToken\"\x83\x01\n" +
	"\x1eSendMultiRecipientStoryRequest\x12\x16\n" +
	"\x06urgent\x18\x01 \x01(\bR\x06urgent\x12I\n" +
	"\amessage\x18\x02 \x01(\v2/.org.signal.chat.messages.MultiRecipientMessageR\amessage\"w\n" +
	"\x15MultiRecipientSuccess\x12^\n" +
	"\x15unresolved_recipients\x18\x01 \x03(\v2).org.signal.chat.common.ServiceIdentifierR\x14unresolvedRecipients\"\xb0\x03\n" +
	"!SendMultiRecipientMessageResponse\x12K\n" +
	"\asuccess\x18\x01 \x01(\v2/.org.signal.chat.messages.MultiRecipientSuccessH\x00R\asuccess\x12\x82\x01\n" +
	"\x12mismatched_devices\x18\x02 \x01(\v29.org.signal.chat.messages.MultiRecipientMismatchedDevicesB\x16\xc2\xd5\"\x12mismatched_devicesH\x00R\x11mismatchedDevices\x12\xac\x01\n" +
	"!failed_unidentified_authorization\x18\x03 \x01(\v27.org.signal.chat.errors.FailedUnidentifiedAuthorizationB%\xc2\xd5\"!failed_unidentified_authorizationH\x00R\x1ffailedUnidentifiedAuthorizationB\n" +
	"\n" +
	"\bresponse\"\xfe\x01\n" +
	"\x11MismatchedDevices\x12X\n" +
	"\x12service_identifier\x18\x01 \x01(\v2).org.signal.chat.common.ServiceIdentifierR\x11serviceIdentifier\x121\n" +
	"\x0fmissing_devices\x18\x02 \x03(\rB\bҗ\"\x042\x02\x10\x7fR\x0emissingDevices\x12-\n" +
	"\rextra_devices\x18\x03 \x03(\rB\bҗ\"\x042\x02\x10\x7fR\fextraDevices\x12-\n" +
	"\rstale_devices\x18\x04 \x03(\rB\bҗ\"\x042\x02\x10\x7fR\fstaleDevices\"}\n" +
	"\x1fMultiRecipientMismatchedDevices\x12Z\n" +
	"\x12mismatched_devices\x18\x01 \x03(\v2+.org.signal.chat.messages.MismatchedDevicesR\x11mismatchedDevices\"\xa1\x02\n" +
	"\x11ChallengeRequired\x12\x14\n" +
	"\x05token\x18\x01 \x01(\tR\x05token\x12f\n" +
	"\x11challenge_options\x18\x02 \x03(\x0e29.org.signal.chat.messages.ChallengeRequired.ChallengeTypeR\x10challengeOptions\x123\n" +
	"\x13retry_after_seconds\x18\x03 \x01(\x04H\x00R\x11retryAfterSeconds\x88\x01\x01\"A\n" +
	"\rChallengeType\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\v\n" +
	"\aCAPTCHA\x10\x01\x12\x12\n" +
	"\x0ePUSH_CHALLENGE\x10\x02B\x16\n" +
	"\x14_retry_after_seconds*z\n" +
	"\x0fSendMessageType\x12\x0f\n" +
	"\vUNSPECIFIED\x10\x00\x12\x12\n" +
	"\x0eDOUBLE_RATCHET\x10\x01\x12\x12\n" +
	"\x0ePREKEY_MESSAGE\x10\x02\x12\x15\n" +
	"\x11PLAINTEXT_CONTENT\x10\x03\x12\x17\n" +
	"\x13UNIDENTIFIED_SENDER\x10\x042\xa1\x03\n" +
	"\bMessages\x12\x92\x01\n" +
	"\vSendMessage\x12?.org.signal.chat.messages.SendAuthenticatedSenderMessageRequest\x1a@.org.signal.chat.messages.SendMessageAuthenticatedSenderResponse\"\x00\x12\x87\x01\n" +
	"\x0fSendSyncMessage\x120.org.signal.chat.messages.SendSyncMessageRequest\x1a@.org.signal.chat.messages.SendMessageAuthenticatedSenderResponse\"\x00\x12p\n" +
	"\vGetMessages\x12,.org.signal.chat.messages.GetMessagesRequest\x1a-.org.signal.chat.messages.GetMessagesResponse\"\x00(\x010\x01\x1a\x04\xc8\xd5\"\x012\xc2\x04\n" +
	"\x11MessagesAnonymous\x12\x87\x01\n" +
	"\x1aSendSingleRecipientMessage\x128.org.signal.chat.messages.SendSealedSenderMessageRequest\x1a-.org.signal.chat.messages.SendMessageResponse\"\x00\x12\x96\x01\n" +
	"\x19SendMultiRecipientMessage\x12:.org.signal.chat.messages.SendMultiRecipientMessageRequest\x1a;.org.signal.chat.messages.SendMultiRecipientMessageResponse\"\x00\x12o\n" +
	"\tSendStory\x121.org.signal.chat.messages.SendStoryMessageRequest\x1a-.org.signal.chat.messages.SendMessageResponse\"\x00\x12\x92\x01\n" +
	"\x17SendMultiRecipientStory\x128.org.signal.chat.messages.SendMultiRecipientStoryRequest\x1a;.org.signal.chat.messages.SendMultiRecipientMessageResponse\"\x00\x1a\x04\xc8\xd5\"\x02B\x02P\x01b\x06proto3"

var (
	file_org_signal_chat_messages_proto_rawDescOnce sync.Once
	file_org_signal_chat_messages_proto_rawDescData []byte
)

func file_org_signal_chat_messages_proto_rawDescGZIP() []byte {
	file_org_signal_chat_messages_proto_rawDescOnce.Do(func() {
		file_org_signal_chat_messages_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_org_signal_chat_messages_proto_rawDesc), len(file_org_signal_chat_messages_proto_rawDesc)))
	})
	return file_org_signal_chat_messages_proto_rawDescData
}

var file_org_signal_chat_messages_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_org_signal_chat_messages_proto_msgTypes = make([]protoimpl.MessageInfo, 21)
var file_org_signal_chat_messages_proto_goTypes = []any{
	(SendMessageType)(0),                             // 0: org.signal.chat.messages.SendMessageType
	(ChallengeRequired_ChallengeType)(0),             // 1: org.signal.chat.messages.ChallengeRequired.ChallengeType
	(*GetMessagesRequest)(nil),                       // 2: org.signal.chat.messages.GetMessagesRequest
	(*GetMessagesStreamClosed)(nil),                  // 3: org.signal.chat.messages.GetMessagesStreamClosed
	(*GetMessagesResponse)(nil),                      // 4: org.signal.chat.messages.GetMessagesResponse
	(*IndividualRecipientMessageBundle)(nil),         // 5: org.signal.chat.messages.IndividualRecipientMessageBundle
	(*SendAuthenticatedSenderMessageRequest)(nil),    // 6: org.signal.chat.messages.SendAuthenticatedSenderMessageRequest
	(*SendMessageAuthenticatedSenderResponse)(nil),   // 7: org.signal.chat.messages.SendMessageAuthenticatedSenderResponse
	(*SendSyncMessageRequest)(nil),                   // 8: org.signal.chat.messages.SendSyncMessageRequest
	(*SendSealedSenderMessageRequest)(nil),           // 9: org.signal.chat.messages.SendSealedSenderMessageRequest
	(*SendStoryMessageRequest)(nil),                  // 10: org.signal.chat.messages.SendStoryMessageRequest
	(*SendMessageResponse)(nil),                      // 11: org.signal.chat.messages.SendMessageResponse
	(*MultiRecipientMessage)(nil),                    // 12: org.signal.chat.messages.MultiRecipientMessage
	(*SendMultiRecipientMessageRequest)(nil),         // 13: org.signal.chat.messages.SendMultiRecipientMessageRequest
	(*SendMultiRecipientStoryRequest)(nil),           // 14: org.signal.chat.messages.SendMultiRecipientStoryRequest
	(*MultiRecipientSuccess)(nil),                    // 15: org.signal.chat.messages.MultiRecipientSuccess
	(*SendMultiRecipientMessageResponse)(nil),        // 16: org.signal.chat.messages.SendMultiRecipientMessageResponse
	(*MismatchedDevices)(nil),                        // 17: org.signal.chat.messages.MismatchedDevices
	(*MultiRecipientMismatchedDevices)(nil),          // 18: org.signal.chat.messages.MultiRecipientMismatchedDevices
	(*ChallengeRequired)(nil),                        // 19: org.signal.chat.messages.ChallengeRequired
	(*GetMessagesRequest_GetMessageOptions)(nil),     // 20: org.signal.chat.messages.GetMessagesRequest.GetMessageOptions
	(*IndividualRecipientMessageBundle_Message)(nil), // 21: org.signal.chat.messages.IndividualRecipientMessageBundle.Message
	nil,                              // 22: org.signal.chat.messages.IndividualRecipientMessageBundle.MessagesEntry
	(*emptypb.Empty)(nil),            // 23: google.protobuf.Empty
	(*signalpb.Envelope)(nil),        // 24: signalservice.Envelope
	(*common.ServiceIdentifier)(nil), // 25: org.signal.chat.common.ServiceIdentifier
	(*errors.NotFound)(nil),          // 26: org.signal.chat.errors.NotFound
	(*errors.FailedUnidentifiedAuthorization)(nil), // 27: org.signal.chat.errors.FailedUnidentifiedAuthorization
}
var file_org_signal_chat_messages_proto_depIdxs = []int32{
	20, // 0: org.signal.chat.messages.GetMessagesRequest.options:type_name -> org.signal.chat.messages.GetMessagesRequest.GetMessageOptions
	23, // 1: org.signal.chat.messages.GetMessagesStreamClosed.conflicting_stream:type_name -> google.protobuf.Empty
	24, // 2: org.signal.chat.messages.GetMessagesResponse.envelope:type_name -> signalservice.Envelope
	23, // 3: org.signal.chat.messages.GetMessagesResponse.queue_empty:type_name -> google.protobuf.Empty
	22, // 4: org.signal.chat.messages.IndividualRecipientMessageBundle.messages:type_name -> org.signal.chat.messages.IndividualRecipientMessageBundle.MessagesEntry
	25, // 5: org.signal.chat.messages.SendAuthenticatedSenderMessageRequest.destination:type_name -> org.signal.chat.common.ServiceIdentifier
	5,  // 6: org.signal.chat.messages.SendAuthenticatedSenderMessageRequest.messages:type_name -> org.signal.chat.messages.IndividualRecipientMessageBundle
	23, // 7: org.signal.chat.messages.SendMessageAuthenticatedSenderResponse.success:type_name -> google.protobuf.Empty
	17, // 8: org.signal.chat.messages.SendMessageAuthenticatedSenderResponse.mismatched_devices:type_name -> org.signal.chat.messages.MismatchedDevices
	19, // 9: org.signal.chat.messages.SendMessageAuthenticatedSenderResponse.challenge_required:type_name -> org.signal.chat.messages.ChallengeRequired
	26, // 10: org.signal.chat.messages.SendMessageAuthenticatedSenderResponse.destination_not_found:type_name -> org.signal.chat.errors.NotFound
	5,  // 11: org.signal.chat.messages.SendSyncMessageRequest.messages:type_name -> org.signal.chat.messages.IndividualRecipientMessageBundle
	25, // 12: org.signal.chat.messages.SendSealedSenderMessageRequest.destination:type_name -> org.signal.chat.common.ServiceIdentifier
	5,  // 13: org.signal.chat.messages.SendSealedSenderMessageRequest.messages:type_name -> org.signal.chat.messages.IndividualRecipientMessageBundle
	23, // 14: org.signal.chat.messages.SendSealedSenderMessageRequest.unrestricted_access:type_name -> google.protobuf.Empty
	25, // 15: org.signal.chat.messages.SendStoryMessageRequest.destination:type_name -> org.signal.chat.common.ServiceIdentifier
	5,  // 16: org.signal.chat.messages.SendStoryMessageRequest.messages:type_name -> org.signal.chat.messages.IndividualRecipientMessageBundle
	23, // 17: org.signal.chat.messages.SendMessageResponse.success:type_name -> google.protobuf.Empty
	17, // 18: org.signal.chat.messages.SendMessageResponse.mismatched_devices:type_name -> org.signal.chat.messages.MismatchedDevices
	27, // 19: org.signal.chat.messages.SendMessageResponse.failed_unidentified_authorization:type_name -> org.signal.chat.errors.FailedUnidentifiedAuthorization
	26, // 20: org.signal.chat.messages.SendMessageResponse.destination_not_found:type_name -> org.signal.chat.errors.NotFound
	12, // 21: org.signal.chat.messages.SendMultiRecipientMessageRequest.message:type_name -> org.signal.chat.messages.MultiRecipientMessage
	12, // 22: org.signal.chat.messages.SendMultiRecipientStoryRequest.message:type_name -> org.signal.chat.messages.MultiRecipientMessage
	25, // 23: org.signal.chat.messages.MultiRecipientSuccess.unresolved_recipients:type_name -> org.signal.chat.common.ServiceIdentifier
	15, // 24: org.signal.chat.messages.SendMultiRecipientMessageResponse.success:type_name -> org.signal.chat.messages.MultiRecipientSuccess
	18, // 25: org.signal.chat.messages.SendMultiRecipientMessageResponse.mismatched_devices:type_name -> org.signal.chat.messages.MultiRecipientMismatchedDevices
	27, // 26: org.signal.chat.messages.SendMultiRecipientMessageResponse.failed_unidentified_authorization:type_name -> org.signal.chat.errors.FailedUnidentifiedAuthorization
	25, // 27: org.signal.chat.messages.MismatchedDevices.service_identifier:type_name -> org.signal.chat.common.ServiceIdentifier
	17, // 28: org.signal.chat.messages.MultiRecipientMismatchedDevices.mismatched_devices:type_name -> org.signal.chat.messages.MismatchedDevices
	1,  // 29: org.signal.chat.messages.ChallengeRequired.challenge_options:type_name -> org.signal.chat.messages.ChallengeRequired.ChallengeType
	0,  // 30: org.signal.chat.messages.IndividualRecipientMessageBundle.Message.type:type_name -> org.signal.chat.messages.SendMessageType
	21, // 31: org.signal.chat.messages.IndividualRecipientMessageBundle.MessagesEntry.value:type_name -> org.signal.chat.messages.IndividualRecipientMessageBundle.Message
	6,  // 32: org.signal.chat.messages.Messages.SendMessage:input_type -> org.signal.chat.messages.SendAuthenticatedSenderMessageRequest
	8,  // 33: org.signal.chat.messages.Messages.SendSyncMessage:input_type -> org.signal.chat.messages.SendSyncMessageRequest
	2,  // 34: org.signal.chat.messages.Messages.GetMessages:input_type -> org.signal.chat.messages.GetMessagesRequest
	9,  // 35: org.signal.chat.messages.MessagesAnonymous.SendSingleRecipientMessage:input_type -> org.signal.chat.messages.SendSealedSenderMessageRequest
	13, // 36: org.signal.chat.messages.MessagesAnonymous.SendMultiRecipientMessage:input_type -> org.signal.chat.messages.SendMultiRecipientMessageRequest
	10, // 37: org.signal.chat.messages.MessagesAnonymous.SendStory:input_type -> org.signal.chat.messages.SendStoryMessageRequest
	14, // 38: org.signal.chat.messages.MessagesAnonymous.SendMultiRecipientStory:input_type -> org.signal.chat.messages.SendMultiRecipientStoryRequest
	7,  // 39: org.signal.chat.messages.Messages.SendMessage:output_type -> org.signal.chat.messages.SendMessageAuthenticatedSenderResponse
	7,  // 40: org.signal.chat.messages.Messages.SendSyncMessage:output_type -> org.signal.chat.messages.SendMessageAuthenticatedSenderResponse
	4,  // 41: org.signal.chat.messages.Messages.GetMessages:output_type -> org.signal.chat.messages.GetMessagesResponse
	11, // 42: org.signal.chat.messages.MessagesAnonymous.SendSingleRecipientMessage:output_type -> org.signal.chat.messages.SendMessageResponse
	16, // 43: org.signal.chat.messages.MessagesAnonymous.SendMultiRecipientMessage:output_type -> org.signal.chat.messages.SendMultiRecipientMessageResponse
	11, // 44: org.signal.chat.messages.MessagesAnonymous.SendStory:output_type -> org.signal.chat.messages.SendMessageResponse
	16, // 45: org.signal.chat.messages.MessagesAnonymous.SendMultiRecipientStory:output_type -> org.signal.chat.messages.SendMultiRecipientMessageResponse
	39, // [39:46] is the sub-list for method output_type
	32, // [32:39] is the sub-list for method input_type
	32, // [32:32] is the sub-list for extension type_name
	32, // [32:32] is the sub-list for extension extendee
	0,  // [0:32] is the sub-list for field type_name
}

func init() { file_org_signal_chat_messages_proto_init() }
func file_org_signal_chat_messages_proto_init() {
	if File_org_signal_chat_messages_proto != nil {
		return
	}
	file_org_signal_chat_messages_proto_msgTypes[0].OneofWrappers = []any{
		(*GetMessagesRequest_Options)(nil),
		(*GetMessagesRequest_ServerGuidAck)(nil),
	}
	file_org_signal_chat_messages_proto_msgTypes[1].OneofWrappers = []any{
		(*GetMessagesStreamClosed_ConflictingStream)(nil),
	}
	file_org_signal_chat_messages_proto_msgTypes[2].OneofWrappers = []any{
		(*GetMessagesResponse_Envelope)(nil),
		(*GetMessagesResponse_QueueEmpty)(nil),
	}
	file_org_signal_chat_messages_proto_msgTypes[5].OneofWrappers = []any{
		(*SendMessageAuthenticatedSenderResponse_Success)(nil),
		(*SendMessageAuthenticatedSenderResponse_MismatchedDevices)(nil),
		(*SendMessageAuthenticatedSenderResponse_ChallengeRequired)(nil),
		(*SendMessageAuthenticatedSenderResponse_DestinationNotFound)(nil),
	}
	file_org_signal_chat_messages_proto_msgTypes[7].OneofWrappers = []any{
		(*SendSealedSenderMessageRequest_UnidentifiedAccessKey)(nil),
		(*SendSealedSenderMessageRequest_GroupSendToken)(nil),
		(*SendSealedSenderMessageRequest_UnrestrictedAccess)(nil),
	}
	file_org_signal_chat_messages_proto_msgTypes[9].OneofWrappers = []any{
		(*SendMessageResponse_Success)(nil),
		(*SendMessageResponse_MismatchedDevices)(nil),
		(*SendMessageResponse_FailedUnidentifiedAuthorization)(nil),
		(*SendMessageResponse_DestinationNotFound)(nil),
	}
	file_org_signal_chat_messages_proto_msgTypes[14].OneofWrappers = []any{
		(*SendMultiRecipientMessageResponse_Success)(nil),
		(*SendMultiRecipientMessageResponse_MismatchedDevices)(nil),
		(*SendMultiRecipientMessageResponse_FailedUnidentifiedAuthorization)(nil),
	}
	file_org_signal_chat_messages_proto_msgTypes[17].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_org_signal_chat_messages_proto_rawDesc), len(file_org_signal_chat_messages_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   21,
			NumExtensions: 0,
			NumServices:   2,
		},
		GoTypes:           file_org_signal_chat_messages_proto_goTypes,
		DependencyIndexes: file_org_signal_chat_messages_proto_depIdxs,
		EnumInfos:         file_org_signal_chat_messages_proto_enumTypes,
		MessageInfos:      file_org_signal_chat_messages_proto_msgTypes,
	}.Build()
	File_org_signal_chat_messages_proto = out.File
	file_org_signal_chat_messages_proto_goTypes = nil
	file_org_signal_chat_messages_proto_depIdxs = nil
}