mirror of
https://github.com/mautrix/signal.git
synced 2026-09-17 16:17:01 -04:00
1986 lines
78 KiB
Go
Generated
1986 lines
78 KiB
Go
Generated
//
|
|
// 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
|
|
}
|