bertypushtypes.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pushtypes/bertypushtypes.proto

package pushtypes

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type PushServiceTokenType int32

const (
	PushServiceTokenType_PushTokenUndefined PushServiceTokenType = 0
	// PushTokenMQTT: Platform independent
	PushServiceTokenType_PushTokenMQTT PushServiceTokenType = 1
	// PushTokenApplePushNotificationService: iOS, iPadOS, tvOS, macOS
	PushServiceTokenType_PushTokenApplePushNotificationService PushServiceTokenType = 2
	// PushTokenFirebaseCloudMessaging: Android with GMS, Chrome OS
	PushServiceTokenType_PushTokenFirebaseCloudMessaging PushServiceTokenType = 3
	// PushTokenWindowsPushNotificationService: Windows, XBox
	PushServiceTokenType_PushTokenWindowsPushNotificationService PushServiceTokenType = 4
	// PushTokenHuaweiPushKit: Huawei Android devices with AppGallery
	PushServiceTokenType_PushTokenHuaweiPushKit PushServiceTokenType = 5
	// PushTokenAmazonDeviceMessaging: Fire OS devices
	PushServiceTokenType_PushTokenAmazonDeviceMessaging PushServiceTokenType = 6
)

var PushServiceTokenType_name = map[int32]string{
	0: "PushTokenUndefined",
	1: "PushTokenMQTT",
	2: "PushTokenApplePushNotificationService",
	3: "PushTokenFirebaseCloudMessaging",
	4: "PushTokenWindowsPushNotificationService",
	5: "PushTokenHuaweiPushKit",
	6: "PushTokenAmazonDeviceMessaging",
}

var PushServiceTokenType_value = map[string]int32{
	"PushTokenUndefined":                      0,
	"PushTokenMQTT":                           1,
	"PushTokenApplePushNotificationService":   2,
	"PushTokenFirebaseCloudMessaging":         3,
	"PushTokenWindowsPushNotificationService": 4,
	"PushTokenHuaweiPushKit":                  5,
	"PushTokenAmazonDeviceMessaging":          6,
}

func (x PushServiceTokenType) String() string {
	return proto.EnumName(PushServiceTokenType_name, int32(x))
}

func (PushServiceTokenType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{0}
}

type PushServicePriority int32

const (
	PushServicePriority_PushPriorityUndefined PushServicePriority = 0
	PushServicePriority_PushPriorityLow       PushServicePriority = 1
	PushServicePriority_PushPriorityNormal    PushServicePriority = 2
)

var PushServicePriority_name = map[int32]string{
	0: "PushPriorityUndefined",
	1: "PushPriorityLow",
	2: "PushPriorityNormal",
}

var PushServicePriority_value = map[string]int32{
	"PushPriorityUndefined": 0,
	"PushPriorityLow":       1,
	"PushPriorityNormal":    2,
}

func (x PushServicePriority) String() string {
	return proto.EnumName(PushServicePriority_name, int32(x))
}

func (PushServicePriority) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{1}
}

type DecryptedPush_PushType int32

const (
	DecryptedPush_Unknown                 DecryptedPush_PushType = 0
	DecryptedPush_Message                 DecryptedPush_PushType = 1
	DecryptedPush_GroupInvitation         DecryptedPush_PushType = 7
	DecryptedPush_ConversationNameChanged DecryptedPush_PushType = 8
	DecryptedPush_MemberNameChanged       DecryptedPush_PushType = 9
	DecryptedPush_MemberDetailsChanged    DecryptedPush_PushType = 11
)

var DecryptedPush_PushType_name = map[int32]string{
	0:  "Unknown",
	1:  "Message",
	7:  "GroupInvitation",
	8:  "ConversationNameChanged",
	9:  "MemberNameChanged",
	11: "MemberDetailsChanged",
}

var DecryptedPush_PushType_value = map[string]int32{
	"Unknown":                 0,
	"Message":                 1,
	"GroupInvitation":         7,
	"ConversationNameChanged": 8,
	"MemberNameChanged":       9,
	"MemberDetailsChanged":    11,
}

func (x DecryptedPush_PushType) String() string {
	return proto.EnumName(DecryptedPush_PushType_name, int32(x))
}

func (DecryptedPush_PushType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{6, 0}
}

type PushServiceReceiver struct {
	// token_type is the type of the token used, it allows us to act as a proxy to the appropriate push server
	TokenType PushServiceTokenType `protobuf:"varint,1,opt,name=token_type,json=tokenType,proto3,enum=berty.push.v1.PushServiceTokenType" json:"token_type,omitempty"`
	// bundle_id is the app identifier
	BundleID string `protobuf:"bytes,2,opt,name=bundle_id,json=bundleId,proto3" json:"bundle_id,omitempty"`
	// token is the device identifier used
	Token []byte `protobuf:"bytes,3,opt,name=token,proto3" json:"token,omitempty"`
	// public_key is the public key which will be used to encrypt the payload
	RecipientPublicKey   []byte   `protobuf:"bytes,4,opt,name=recipient_public_key,json=recipientPublicKey,proto3" json:"recipient_public_key,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PushServiceReceiver) Reset()         { *m = PushServiceReceiver{} }
func (m *PushServiceReceiver) String() string { return proto.CompactTextString(m) }
func (*PushServiceReceiver) ProtoMessage()    {}
func (*PushServiceReceiver) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{0}
}
func (m *PushServiceReceiver) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceReceiver) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceReceiver.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceReceiver) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceReceiver.Merge(m, src)
}
func (m *PushServiceReceiver) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceReceiver) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceReceiver.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceReceiver proto.InternalMessageInfo

func (m *PushServiceReceiver) GetTokenType() PushServiceTokenType {
	if m != nil {
		return m.TokenType
	}
	return PushServiceTokenType_PushTokenUndefined
}

func (m *PushServiceReceiver) GetBundleID() string {
	if m != nil {
		return m.BundleID
	}
	return ""
}

func (m *PushServiceReceiver) GetToken() []byte {
	if m != nil {
		return m.Token
	}
	return nil
}

func (m *PushServiceReceiver) GetRecipientPublicKey() []byte {
	if m != nil {
		return m.RecipientPublicKey
	}
	return nil
}

type PushServiceServerInfo struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PushServiceServerInfo) Reset()         { *m = PushServiceServerInfo{} }
func (m *PushServiceServerInfo) String() string { return proto.CompactTextString(m) }
func (*PushServiceServerInfo) ProtoMessage()    {}
func (*PushServiceServerInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{1}
}
func (m *PushServiceServerInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceServerInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceServerInfo.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceServerInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceServerInfo.Merge(m, src)
}
func (m *PushServiceServerInfo) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceServerInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceServerInfo.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceServerInfo proto.InternalMessageInfo

type PushServiceServerInfo_Request struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PushServiceServerInfo_Request) Reset()         { *m = PushServiceServerInfo_Request{} }
func (m *PushServiceServerInfo_Request) String() string { return proto.CompactTextString(m) }
func (*PushServiceServerInfo_Request) ProtoMessage()    {}
func (*PushServiceServerInfo_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{1, 0}
}
func (m *PushServiceServerInfo_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceServerInfo_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceServerInfo_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceServerInfo_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceServerInfo_Request.Merge(m, src)
}
func (m *PushServiceServerInfo_Request) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceServerInfo_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceServerInfo_Request.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceServerInfo_Request proto.InternalMessageInfo

type PushServiceServerInfo_Reply struct {
	// public_key the public key used to encrypt data to the server (ie. a PushServiceReceiver),
	// to be used with NaCl's Seal and Open
	PublicKey []byte `protobuf:"bytes,1,opt,name=public_key,json=publicKey,proto3" json:"public_key,omitempty"`
	// supported_token_types list of token types supported by the server
	SupportedTokenTypes  []*PushServiceSupportedTokenType `protobuf:"bytes,2,rep,name=supported_token_types,json=supportedTokenTypes,proto3" json:"supported_token_types,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                         `json:"-"`
	XXX_unrecognized     []byte                           `json:"-"`
	XXX_sizecache        int32                            `json:"-"`
}

func (m *PushServiceServerInfo_Reply) Reset()         { *m = PushServiceServerInfo_Reply{} }
func (m *PushServiceServerInfo_Reply) String() string { return proto.CompactTextString(m) }
func (*PushServiceServerInfo_Reply) ProtoMessage()    {}
func (*PushServiceServerInfo_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{1, 1}
}
func (m *PushServiceServerInfo_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceServerInfo_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceServerInfo_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceServerInfo_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceServerInfo_Reply.Merge(m, src)
}
func (m *PushServiceServerInfo_Reply) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceServerInfo_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceServerInfo_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceServerInfo_Reply proto.InternalMessageInfo

func (m *PushServiceServerInfo_Reply) GetPublicKey() []byte {
	if m != nil {
		return m.PublicKey
	}
	return nil
}

func (m *PushServiceServerInfo_Reply) GetSupportedTokenTypes() []*PushServiceSupportedTokenType {
	if m != nil {
		return m.SupportedTokenTypes
	}
	return nil
}

type PushServiceSupportedTokenType struct {
	AppBundleID          string               `protobuf:"bytes,1,opt,name=app_bundle_id,json=appBundleId,proto3" json:"app_bundle_id,omitempty"`
	TokenType            PushServiceTokenType `protobuf:"varint,2,opt,name=token_type,json=tokenType,proto3,enum=berty.push.v1.PushServiceTokenType" json:"token_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *PushServiceSupportedTokenType) Reset()         { *m = PushServiceSupportedTokenType{} }
func (m *PushServiceSupportedTokenType) String() string { return proto.CompactTextString(m) }
func (*PushServiceSupportedTokenType) ProtoMessage()    {}
func (*PushServiceSupportedTokenType) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{2}
}
func (m *PushServiceSupportedTokenType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceSupportedTokenType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceSupportedTokenType.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceSupportedTokenType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceSupportedTokenType.Merge(m, src)
}
func (m *PushServiceSupportedTokenType) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceSupportedTokenType) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceSupportedTokenType.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceSupportedTokenType proto.InternalMessageInfo

func (m *PushServiceSupportedTokenType) GetAppBundleID() string {
	if m != nil {
		return m.AppBundleID
	}
	return ""
}

func (m *PushServiceSupportedTokenType) GetTokenType() PushServiceTokenType {
	if m != nil {
		return m.TokenType
	}
	return PushServiceTokenType_PushTokenUndefined
}

type PushServiceSend struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PushServiceSend) Reset()         { *m = PushServiceSend{} }
func (m *PushServiceSend) String() string { return proto.CompactTextString(m) }
func (*PushServiceSend) ProtoMessage()    {}
func (*PushServiceSend) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{3}
}
func (m *PushServiceSend) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceSend) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceSend.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceSend) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceSend.Merge(m, src)
}
func (m *PushServiceSend) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceSend) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceSend.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceSend proto.InternalMessageInfo

type PushServiceSend_Request struct {
	Envelope             []byte                       `protobuf:"bytes,1,opt,name=envelope,proto3" json:"envelope,omitempty"`
	Priority             PushServicePriority          `protobuf:"varint,2,opt,name=priority,proto3,enum=berty.push.v1.PushServicePriority" json:"priority,omitempty"`
	Receivers            []*PushServiceOpaqueReceiver `protobuf:"bytes,3,rep,name=receivers,proto3" json:"receivers,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

func (m *PushServiceSend_Request) Reset()         { *m = PushServiceSend_Request{} }
func (m *PushServiceSend_Request) String() string { return proto.CompactTextString(m) }
func (*PushServiceSend_Request) ProtoMessage()    {}
func (*PushServiceSend_Request) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{3, 0}
}
func (m *PushServiceSend_Request) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceSend_Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceSend_Request.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceSend_Request) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceSend_Request.Merge(m, src)
}
func (m *PushServiceSend_Request) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceSend_Request) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceSend_Request.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceSend_Request proto.InternalMessageInfo

func (m *PushServiceSend_Request) GetEnvelope() []byte {
	if m != nil {
		return m.Envelope
	}
	return nil
}

func (m *PushServiceSend_Request) GetPriority() PushServicePriority {
	if m != nil {
		return m.Priority
	}
	return PushServicePriority_PushPriorityUndefined
}

func (m *PushServiceSend_Request) GetReceivers() []*PushServiceOpaqueReceiver {
	if m != nil {
		return m.Receivers
	}
	return nil
}

type PushServiceSend_Reply struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PushServiceSend_Reply) Reset()         { *m = PushServiceSend_Reply{} }
func (m *PushServiceSend_Reply) String() string { return proto.CompactTextString(m) }
func (*PushServiceSend_Reply) ProtoMessage()    {}
func (*PushServiceSend_Reply) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{3, 1}
}
func (m *PushServiceSend_Reply) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceSend_Reply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceSend_Reply.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceSend_Reply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceSend_Reply.Merge(m, src)
}
func (m *PushServiceSend_Reply) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceSend_Reply) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceSend_Reply.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceSend_Reply proto.InternalMessageInfo

type OutOfStoreExposedData struct {
	Nonce                []byte   `protobuf:"bytes,1,opt,name=nonce,proto3" json:"nonce,omitempty"`
	Box                  []byte   `protobuf:"bytes,2,opt,name=box,proto3" json:"box,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OutOfStoreExposedData) Reset()         { *m = OutOfStoreExposedData{} }
func (m *OutOfStoreExposedData) String() string { return proto.CompactTextString(m) }
func (*OutOfStoreExposedData) ProtoMessage()    {}
func (*OutOfStoreExposedData) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{4}
}
func (m *OutOfStoreExposedData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OutOfStoreExposedData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutOfStoreExposedData.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *OutOfStoreExposedData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutOfStoreExposedData.Merge(m, src)
}
func (m *OutOfStoreExposedData) XXX_Size() int {
	return m.Size()
}
func (m *OutOfStoreExposedData) XXX_DiscardUnknown() {
	xxx_messageInfo_OutOfStoreExposedData.DiscardUnknown(m)
}

var xxx_messageInfo_OutOfStoreExposedData proto.InternalMessageInfo

func (m *OutOfStoreExposedData) GetNonce() []byte {
	if m != nil {
		return m.Nonce
	}
	return nil
}

func (m *OutOfStoreExposedData) GetBox() []byte {
	if m != nil {
		return m.Box
	}
	return nil
}

type PushServiceOpaqueReceiver struct {
	OpaqueToken          []byte   `protobuf:"bytes,1,opt,name=opaque_token,json=opaqueToken,proto3" json:"opaque_token,omitempty"`
	ServiceAddr          string   `protobuf:"bytes,2,opt,name=service_addr,json=serviceAddr,proto3" json:"service_addr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PushServiceOpaqueReceiver) Reset()         { *m = PushServiceOpaqueReceiver{} }
func (m *PushServiceOpaqueReceiver) String() string { return proto.CompactTextString(m) }
func (*PushServiceOpaqueReceiver) ProtoMessage()    {}
func (*PushServiceOpaqueReceiver) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{5}
}
func (m *PushServiceOpaqueReceiver) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *PushServiceOpaqueReceiver) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushServiceOpaqueReceiver.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *PushServiceOpaqueReceiver) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushServiceOpaqueReceiver.Merge(m, src)
}
func (m *PushServiceOpaqueReceiver) XXX_Size() int {
	return m.Size()
}
func (m *PushServiceOpaqueReceiver) XXX_DiscardUnknown() {
	xxx_messageInfo_PushServiceOpaqueReceiver.DiscardUnknown(m)
}

var xxx_messageInfo_PushServiceOpaqueReceiver proto.InternalMessageInfo

func (m *PushServiceOpaqueReceiver) GetOpaqueToken() []byte {
	if m != nil {
		return m.OpaqueToken
	}
	return nil
}

func (m *PushServiceOpaqueReceiver) GetServiceAddr() string {
	if m != nil {
		return m.ServiceAddr
	}
	return ""
}

type DecryptedPush struct {
	AccountID               string                 `protobuf:"bytes,1,opt,name=account_id,json=accountId,proto3" json:"account_id,omitempty"`
	AccountName             string                 `protobuf:"bytes,2,opt,name=account_name,json=accountName,proto3" json:"account_name,omitempty"`
	ConversationPublicKey   string                 `protobuf:"bytes,3,opt,name=conversation_public_key,json=conversationPublicKey,proto3" json:"conversation_public_key,omitempty"`
	ConversationDisplayName string                 `protobuf:"bytes,4,opt,name=conversation_display_name,json=conversationDisplayName,proto3" json:"conversation_display_name,omitempty"`
	MemberPublicKey         string                 `protobuf:"bytes,5,opt,name=member_public_key,json=memberPublicKey,proto3" json:"member_public_key,omitempty"`
	MemberDisplayName       string                 `protobuf:"bytes,6,opt,name=member_display_name,json=memberDisplayName,proto3" json:"member_display_name,omitempty"`
	PushType                DecryptedPush_PushType `protobuf:"varint,7,opt,name=push_type,json=pushType,proto3,enum=berty.push.v1.DecryptedPush_PushType" json:"push_type,omitempty"`
	PayloadAttrsJSON        string                 `protobuf:"bytes,8,opt,name=payload_attrs_json,json=payloadAttrsJson,proto3" json:"payload_attrs_json,omitempty"`
	DeepLink                string                 `protobuf:"bytes,9,opt,name=deep_link,json=deepLink,proto3" json:"deep_link,omitempty"`
	AlreadyReceived         bool                   `protobuf:"varint,10,opt,name=already_received,json=alreadyReceived,proto3" json:"already_received,omitempty"`
	AccountMuted            bool                   `protobuf:"varint,11,opt,name=account_muted,json=accountMuted,proto3" json:"account_muted,omitempty"`
	ConversationMuted       bool                   `protobuf:"varint,12,opt,name=conversation_muted,json=conversationMuted,proto3" json:"conversation_muted,omitempty"`
	HidePreview             bool                   `protobuf:"varint,13,opt,name=hide_preview,json=hidePreview,proto3" json:"hide_preview,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}               `json:"-"`
	XXX_unrecognized        []byte                 `json:"-"`
	XXX_sizecache           int32                  `json:"-"`
}

func (m *DecryptedPush) Reset()         { *m = DecryptedPush{} }
func (m *DecryptedPush) String() string { return proto.CompactTextString(m) }
func (*DecryptedPush) ProtoMessage()    {}
func (*DecryptedPush) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{6}
}
func (m *DecryptedPush) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DecryptedPush) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DecryptedPush.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DecryptedPush) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DecryptedPush.Merge(m, src)
}
func (m *DecryptedPush) XXX_Size() int {
	return m.Size()
}
func (m *DecryptedPush) XXX_DiscardUnknown() {
	xxx_messageInfo_DecryptedPush.DiscardUnknown(m)
}

var xxx_messageInfo_DecryptedPush proto.InternalMessageInfo

func (m *DecryptedPush) GetAccountID() string {
	if m != nil {
		return m.AccountID
	}
	return ""
}

func (m *DecryptedPush) GetAccountName() string {
	if m != nil {
		return m.AccountName
	}
	return ""
}

func (m *DecryptedPush) GetConversationPublicKey() string {
	if m != nil {
		return m.ConversationPublicKey
	}
	return ""
}

func (m *DecryptedPush) GetConversationDisplayName() string {
	if m != nil {
		return m.ConversationDisplayName
	}
	return ""
}

func (m *DecryptedPush) GetMemberPublicKey() string {
	if m != nil {
		return m.MemberPublicKey
	}
	return ""
}

func (m *DecryptedPush) GetMemberDisplayName() string {
	if m != nil {
		return m.MemberDisplayName
	}
	return ""
}

func (m *DecryptedPush) GetPushType() DecryptedPush_PushType {
	if m != nil {
		return m.PushType
	}
	return DecryptedPush_Unknown
}

func (m *DecryptedPush) GetPayloadAttrsJSON() string {
	if m != nil {
		return m.PayloadAttrsJSON
	}
	return ""
}

func (m *DecryptedPush) GetDeepLink() string {
	if m != nil {
		return m.DeepLink
	}
	return ""
}

func (m *DecryptedPush) GetAlreadyReceived() bool {
	if m != nil {
		return m.AlreadyReceived
	}
	return false
}

func (m *DecryptedPush) GetAccountMuted() bool {
	if m != nil {
		return m.AccountMuted
	}
	return false
}

func (m *DecryptedPush) GetConversationMuted() bool {
	if m != nil {
		return m.ConversationMuted
	}
	return false
}

func (m *DecryptedPush) GetHidePreview() bool {
	if m != nil {
		return m.HidePreview
	}
	return false
}

type FormatedPush struct {
	PushType               DecryptedPush_PushType `protobuf:"varint,1,opt,name=push_type,json=pushType,proto3,enum=berty.push.v1.DecryptedPush_PushType" json:"push_type,omitempty"`
	Title                  string                 `protobuf:"bytes,2,opt,name=title,proto3" json:"title,omitempty"`
	Subtitle               string                 `protobuf:"bytes,3,opt,name=subtitle,proto3" json:"subtitle,omitempty"`
	Body                   string                 `protobuf:"bytes,4,opt,name=body,proto3" json:"body,omitempty"`
	DeepLink               string                 `protobuf:"bytes,5,opt,name=deep_link,json=deepLink,proto3" json:"deep_link,omitempty"`
	Muted                  bool                   `protobuf:"varint,6,opt,name=muted,proto3" json:"muted,omitempty"`
	HidePreview            bool                   `protobuf:"varint,7,opt,name=hide_preview,json=hidePreview,proto3" json:"hide_preview,omitempty"`
	ConversationIdentifier string                 `protobuf:"bytes,8,opt,name=conversation_identifier,json=conversationIdentifier,proto3" json:"conversation_identifier,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}               `json:"-"`
	XXX_unrecognized       []byte                 `json:"-"`
	XXX_sizecache          int32                  `json:"-"`
}

func (m *FormatedPush) Reset()         { *m = FormatedPush{} }
func (m *FormatedPush) String() string { return proto.CompactTextString(m) }
func (*FormatedPush) ProtoMessage()    {}
func (*FormatedPush) Descriptor() ([]byte, []int) {
	return fileDescriptor_de7e1eb2266361d5, []int{7}
}
func (m *FormatedPush) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FormatedPush) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FormatedPush.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *FormatedPush) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FormatedPush.Merge(m, src)
}
func (m *FormatedPush) XXX_Size() int {
	return m.Size()
}
func (m *FormatedPush) XXX_DiscardUnknown() {
	xxx_messageInfo_FormatedPush.DiscardUnknown(m)
}

var xxx_messageInfo_FormatedPush proto.InternalMessageInfo

func (m *FormatedPush) GetPushType() DecryptedPush_PushType {
	if m != nil {
		return m.PushType
	}
	return DecryptedPush_Unknown
}

func (m *FormatedPush) GetTitle() string {
	if m != nil {
		return m.Title
	}
	return ""
}

func (m *FormatedPush) GetSubtitle() string {
	if m != nil {
		return m.Subtitle
	}
	return ""
}

func (m *FormatedPush) GetBody() string {
	if m != nil {
		return m.Body
	}
	return ""
}

func (m *FormatedPush) GetDeepLink() string {
	if m != nil {
		return m.DeepLink
	}
	return ""
}

func (m *FormatedPush) GetMuted() bool {
	if m != nil {
		return m.Muted
	}
	return false
}

func (m *FormatedPush) GetHidePreview() bool {
	if m != nil {
		return m.HidePreview
	}
	return false
}

func (m *FormatedPush) GetConversationIdentifier() string {
	if m != nil {
		return m.ConversationIdentifier
	}
	return ""
}

func init() {
	proto.RegisterEnum("berty.push.v1.PushServiceTokenType", PushServiceTokenType_name, PushServiceTokenType_value)
	proto.RegisterEnum("berty.push.v1.PushServicePriority", PushServicePriority_name, PushServicePriority_value)
	proto.RegisterEnum("berty.push.v1.DecryptedPush_PushType", DecryptedPush_PushType_name, DecryptedPush_PushType_value)
	proto.RegisterType((*PushServiceReceiver)(nil), "berty.push.v1.PushServiceReceiver")
	proto.RegisterType((*PushServiceServerInfo)(nil), "berty.push.v1.PushServiceServerInfo")
	proto.RegisterType((*PushServiceServerInfo_Request)(nil), "berty.push.v1.PushServiceServerInfo.Request")
	proto.RegisterType((*PushServiceServerInfo_Reply)(nil), "berty.push.v1.PushServiceServerInfo.Reply")
	proto.RegisterType((*PushServiceSupportedTokenType)(nil), "berty.push.v1.PushServiceSupportedTokenType")
	proto.RegisterType((*PushServiceSend)(nil), "berty.push.v1.PushServiceSend")
	proto.RegisterType((*PushServiceSend_Request)(nil), "berty.push.v1.PushServiceSend.Request")
	proto.RegisterType((*PushServiceSend_Reply)(nil), "berty.push.v1.PushServiceSend.Reply")
	proto.RegisterType((*OutOfStoreExposedData)(nil), "berty.push.v1.OutOfStoreExposedData")
	proto.RegisterType((*PushServiceOpaqueReceiver)(nil), "berty.push.v1.PushServiceOpaqueReceiver")
	proto.RegisterType((*DecryptedPush)(nil), "berty.push.v1.DecryptedPush")
	proto.RegisterType((*FormatedPush)(nil), "berty.push.v1.FormatedPush")
}

func init() { proto.RegisterFile("pushtypes/bertypushtypes.proto", fileDescriptor_de7e1eb2266361d5) }

var fileDescriptor_de7e1eb2266361d5 = []byte{
	// 1219 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x56, 0xef, 0x6e, 0x1b, 0x45,
	0x10, 0xef, 0xd9, 0xe7, 0xe4, 0x3c, 0xb6, 0xc9, 0x65, 0xe3, 0xb4, 0xae, 0xab, 0x26, 0xe9, 0x95,
	0x42, 0x1a, 0x8a, 0x03, 0xad, 0x04, 0x12, 0x1f, 0x40, 0x49, 0x4d, 0xc1, 0xb4, 0xf9, 0xc3, 0x25,
	0x15, 0x12, 0x12, 0x32, 0x67, 0xef, 0xc6, 0x59, 0x72, 0xde, 0xdd, 0xde, 0x9f, 0xa4, 0xc7, 0x13,
	0xf0, 0x08, 0xbc, 0x00, 0xe2, 0x03, 0xea, 0x7b, 0x20, 0xe0, 0x03, 0x4f, 0x10, 0x21, 0x3f, 0x08,
	0x42, 0xbb, 0x7b, 0x77, 0x3e, 0xa7, 0xa4, 0xa0, 0x7e, 0xca, 0xce, 0x6f, 0x7e, 0x33, 0x73, 0x99,
	0xf9, 0xad, 0x77, 0x60, 0x45, 0xc4, 0xe1, 0x71, 0x94, 0x08, 0x12, 0x6e, 0x0e, 0x48, 0x10, 0x25,
	0xb9, 0xd9, 0x11, 0x01, 0x8f, 0x38, 0x6a, 0x28, 0xb4, 0x23, 0xe1, 0xce, 0xe9, 0xfb, 0xed, 0xe6,
	0x88, 0x8f, 0xb8, 0xf2, 0x6c, 0xca, 0x93, 0x26, 0x39, 0x7f, 0x18, 0xb0, 0xb4, 0x1f, 0x87, 0xc7,
	0x07, 0x24, 0x38, 0xa5, 0x43, 0xe2, 0x92, 0x21, 0xa1, 0xa7, 0x24, 0x40, 0xdb, 0x00, 0x11, 0x3f,
	0x21, 0xac, 0x2f, 0x33, 0xb6, 0x8c, 0x35, 0x63, 0xfd, 0x8d, 0xfb, 0xb7, 0x3b, 0x33, 0x19, 0x3b,
	0x85, 0xb8, 0x43, 0xc9, 0x3d, 0x4c, 0x04, 0x71, 0xab, 0x51, 0x76, 0x44, 0x77, 0xa1, 0x3a, 0x88,
	0x19, 0xf6, 0x49, 0x9f, 0xe2, 0x56, 0x69, 0xcd, 0x58, 0xaf, 0x6e, 0xd7, 0x27, 0xe7, 0xab, 0xd6,
	0xb6, 0x02, 0x7b, 0x5d, 0xd7, 0xd2, 0xee, 0x1e, 0x46, 0x4d, 0xa8, 0xa8, 0xb8, 0x56, 0x79, 0xcd,
	0x58, 0xaf, 0xbb, 0xda, 0x40, 0xef, 0x41, 0x33, 0x20, 0x43, 0x2a, 0x28, 0x61, 0x51, 0x5f, 0xc4,
	0x03, 0x9f, 0x0e, 0xfb, 0x27, 0x24, 0x69, 0x99, 0x8a, 0x84, 0x72, 0xdf, 0xbe, 0x72, 0x3d, 0x26,
	0x89, 0xf3, 0xc2, 0x80, 0xe5, 0xc2, 0x67, 0xc9, 0x3f, 0x24, 0xe8, 0xb1, 0x23, 0xde, 0xae, 0xc2,
	0xbc, 0x4b, 0x9e, 0xc5, 0x24, 0x8c, 0xda, 0x3f, 0x18, 0x50, 0x71, 0x89, 0xf0, 0x13, 0x74, 0x13,
	0xa0, 0x90, 0xd6, 0x50, 0x69, 0xab, 0x22, 0xcb, 0x86, 0xbe, 0x85, 0xe5, 0x30, 0x16, 0x82, 0x07,
	0x11, 0xc1, 0xfd, 0x69, 0x3b, 0xc2, 0x56, 0x69, 0xad, 0xbc, 0x5e, 0xbb, 0x7f, 0xef, 0xf2, 0x7e,
	0x1c, 0x64, 0x61, 0xd3, 0xc6, 0x2c, 0x85, 0x2f, 0x61, 0xa1, 0xf3, 0xa3, 0x01, 0x37, 0x5f, 0x19,
	0x86, 0x1e, 0x40, 0xc3, 0x13, 0xa2, 0x3f, 0x6d, 0xa4, 0xa1, 0x1a, 0xb9, 0x30, 0x39, 0x5f, 0xad,
	0x6d, 0x09, 0x91, 0xf7, 0xb2, 0xe6, 0xe5, 0x06, 0xbe, 0x30, 0xbd, 0xd2, 0xeb, 0x4c, 0xcf, 0xf9,
	0xcd, 0x80, 0x85, 0x99, 0x56, 0x32, 0xdc, 0x7e, 0x61, 0xe4, 0x5d, 0x44, 0x6d, 0xb0, 0x08, 0x3b,
	0x25, 0x3e, 0x4f, 0xf5, 0x51, 0x77, 0x73, 0x1b, 0x7d, 0x0c, 0x96, 0x08, 0x28, 0x0f, 0x68, 0x94,
	0xa4, 0xd5, 0x9d, 0xcb, 0xab, 0xef, 0xa7, 0x4c, 0x37, 0x8f, 0x41, 0x8f, 0xa0, 0x1a, 0xa4, 0x4a,
	0x0c, 0x5b, 0x65, 0xd5, 0xec, 0xf5, 0xcb, 0x13, 0xec, 0x09, 0xef, 0x59, 0x9c, 0x4b, 0xd7, 0x9d,
	0x86, 0xb6, 0xe7, 0xd3, 0x41, 0x3b, 0x9f, 0xc0, 0xf2, 0x5e, 0x1c, 0xed, 0x1d, 0x1d, 0x44, 0x3c,
	0x20, 0x9f, 0x3e, 0x17, 0x3c, 0x24, 0xb8, 0xeb, 0x45, 0x9e, 0x14, 0x1e, 0xe3, 0x6c, 0x98, 0xfd,
	0x0b, 0xda, 0x40, 0x36, 0x94, 0x07, 0xfc, 0xb9, 0xfa, 0xf4, 0xba, 0x2b, 0x8f, 0x8e, 0x07, 0xd7,
	0x2f, 0xad, 0x88, 0x6e, 0x41, 0x9d, 0x2b, 0x44, 0x8b, 0x24, 0xcd, 0x55, 0xd3, 0x98, 0x6a, 0xae,
	0xa4, 0x84, 0x3a, 0xb6, 0xef, 0x61, 0x1c, 0xe8, 0xeb, 0xe0, 0xd6, 0x52, 0x6c, 0x0b, 0xe3, 0xc0,
	0xf9, 0x69, 0x0e, 0x1a, 0x5d, 0x32, 0x0c, 0x12, 0x11, 0x11, 0x2c, 0x8b, 0xa1, 0x7b, 0x00, 0xde,
	0x70, 0xc8, 0x63, 0x16, 0x4d, 0x07, 0xdf, 0x98, 0x9c, 0xaf, 0x56, 0xb7, 0x34, 0xda, 0xeb, 0xba,
	0xd5, 0x94, 0xd0, 0xc3, 0xb2, 0x44, 0xc6, 0x66, 0xde, 0x98, 0x64, 0x25, 0x52, 0x6c, 0xd7, 0x1b,
	0x13, 0xf4, 0x01, 0x5c, 0x1b, 0x72, 0x26, 0x5b, 0xe3, 0x45, 0x94, 0xb3, 0xe2, 0x9d, 0x2a, 0x2b,
	0xf6, 0x72, 0xd1, 0x9d, 0x5f, 0x2b, 0xf4, 0x11, 0x5c, 0x9f, 0x89, 0xc3, 0x34, 0x14, 0xbe, 0x97,
	0xe8, 0x3a, 0xa6, 0x8a, 0x9c, 0x49, 0xdc, 0xd5, 0x7e, 0x55, 0x73, 0x03, 0x16, 0xc7, 0x64, 0x3c,
	0x20, 0x41, 0xb1, 0x5a, 0x45, 0xc5, 0x2c, 0x68, 0xc7, 0xb4, 0x4e, 0x07, 0x96, 0x52, 0xee, 0x4c,
	0x85, 0x39, 0xc5, 0x4e, 0xd3, 0x14, 0x73, 0x6f, 0x43, 0x55, 0xea, 0x41, 0xcb, 0x7c, 0x5e, 0x09,
	0xed, 0xce, 0x05, 0x9d, 0xcc, 0x74, 0x54, 0xa9, 0x46, 0x09, 0xdd, 0x12, 0xe9, 0x09, 0x6d, 0x03,
	0x12, 0x5e, 0xe2, 0x73, 0x0f, 0xf7, 0xbd, 0x28, 0x0a, 0xc2, 0xfe, 0x77, 0x21, 0x67, 0x2d, 0x4b,
	0x35, 0xbb, 0x39, 0x39, 0x5f, 0xb5, 0xf7, 0xb5, 0x77, 0x4b, 0x3a, 0xbf, 0x38, 0xd8, 0xdb, 0x75,
	0x6d, 0x51, 0x44, 0x42, 0xce, 0xd0, 0x0d, 0xa8, 0x62, 0x42, 0x44, 0xdf, 0xa7, 0xec, 0xa4, 0x55,
	0x55, 0x5f, 0x6b, 0x49, 0xe0, 0x09, 0x65, 0x27, 0xe8, 0x2e, 0xd8, 0x9e, 0x1f, 0x10, 0x0f, 0x27,
	0xfd, 0x54, 0x99, 0xb8, 0x05, 0x6b, 0xc6, 0xba, 0xe5, 0x2e, 0xa4, 0x78, 0x2a, 0x24, 0x8c, 0x6e,
	0x43, 0x23, 0x1b, 0xe1, 0x38, 0x8e, 0x08, 0x6e, 0xd5, 0x14, 0x2f, 0x9b, 0xeb, 0x8e, 0xc4, 0xd0,
	0xbb, 0x80, 0x66, 0x86, 0xa1, 0x99, 0x75, 0xc5, 0x5c, 0x2c, 0x7a, 0x34, 0xfd, 0x16, 0xd4, 0x8f,
	0x29, 0x26, 0x7d, 0x11, 0x90, 0x53, 0x4a, 0xce, 0x5a, 0x0d, 0x45, 0xac, 0x49, 0x6c, 0x5f, 0x43,
	0xce, 0x2f, 0x06, 0x58, 0x59, 0x67, 0x50, 0x0d, 0xe6, 0x9f, 0xb2, 0x13, 0xc6, 0xcf, 0x98, 0x7d,
	0x45, 0x1a, 0x3b, 0x24, 0x0c, 0xbd, 0x11, 0xb1, 0x0d, 0xb4, 0x04, 0x0b, 0x9f, 0x05, 0x3c, 0x16,
	0x3d, 0x76, 0x4a, 0x23, 0x55, 0xc1, 0x9e, 0x47, 0x37, 0xe0, 0xda, 0xc3, 0x42, 0x4d, 0x39, 0x96,
	0x87, 0xc7, 0x1e, 0x1b, 0x11, 0x6c, 0x5b, 0x68, 0x19, 0x16, 0x77, 0xd4, 0xd0, 0x8a, 0x70, 0x15,
	0xb5, 0xa0, 0xa9, 0xe1, 0x2e, 0x89, 0x3c, 0xea, 0x87, 0x99, 0xa7, 0xe6, 0x98, 0x56, 0xc9, 0x2e,
	0x39, 0xa6, 0x55, 0xb6, 0xcb, 0x8e, 0x69, 0x99, 0xb6, 0xe9, 0x98, 0x56, 0xc5, 0xae, 0x38, 0xa6,
	0x35, 0x67, 0xcf, 0x39, 0xa6, 0x05, 0x36, 0x38, 0x3f, 0x97, 0xa0, 0xfe, 0x88, 0x07, 0x63, 0x2f,
	0xbb, 0x26, 0x33, 0x2a, 0x30, 0x5e, 0x4f, 0x05, 0xf2, 0x01, 0xa2, 0x91, 0x9f, 0xdd, 0x1a, 0x6d,
	0xc8, 0xdf, 0xb8, 0x30, 0x1e, 0x68, 0x87, 0xbe, 0x20, 0xb9, 0x8d, 0x10, 0x98, 0x03, 0x8e, 0x93,
	0x54, 0xfe, 0xea, 0x3c, 0xab, 0x83, 0xca, 0x05, 0x1d, 0x34, 0xa1, 0xa2, 0x47, 0x35, 0xa7, 0x26,
	0xa0, 0x8d, 0x97, 0xc6, 0x33, 0xff, 0xd2, 0x78, 0xd0, 0x87, 0x17, 0x6e, 0x2d, 0xc5, 0x84, 0x45,
	0xf4, 0x88, 0x92, 0x40, 0xcb, 0xd4, 0xbd, 0x5a, 0x74, 0xf7, 0x72, 0xef, 0xc6, 0xdf, 0x06, 0x34,
	0xff, 0xed, 0x67, 0x1e, 0x5d, 0x05, 0xa4, 0x7a, 0x20, 0x81, 0xa7, 0x0c, 0x93, 0x23, 0xca, 0x08,
	0xb6, 0xaf, 0xa0, 0x45, 0x68, 0xe4, 0xf8, 0xce, 0x97, 0x87, 0x87, 0xb6, 0x81, 0xee, 0xc2, 0x9d,
	0x1c, 0xda, 0x12, 0xc2, 0x27, 0xd2, 0xda, 0xe5, 0xb2, 0xc2, 0x50, 0xd5, 0x4b, 0x93, 0xdb, 0x25,
	0x74, 0x1b, 0x56, 0x73, 0xea, 0x23, 0x1a, 0x90, 0x81, 0x17, 0x92, 0x87, 0x3e, 0x8f, 0xb1, 0x96,
	0x10, 0x65, 0x23, 0xbb, 0x8c, 0xde, 0x81, 0xb7, 0x73, 0xd2, 0x57, 0x94, 0x61, 0x7e, 0x16, 0x5e,
	0x96, 0xd1, 0x44, 0x6d, 0xb8, 0x9a, 0x93, 0x3f, 0x8f, 0xbd, 0x33, 0x42, 0xa5, 0xf9, 0x98, 0x46,
	0x76, 0x05, 0x39, 0xb0, 0x32, 0xfd, 0xb0, 0xb1, 0xf7, 0x3d, 0x67, 0x5d, 0x22, 0xc3, 0xa6, 0xc5,
	0xe6, 0x36, 0xbe, 0x99, 0x59, 0x6e, 0xb2, 0x87, 0x06, 0x5d, 0xd7, 0x4b, 0x42, 0x66, 0x17, 0x3b,
	0xb0, 0xa4, 0x1f, 0xbd, 0xcc, 0xf5, 0x84, 0x9f, 0xd9, 0x46, 0xd6, 0xae, 0x0c, 0xdc, 0x95, 0xe2,
	0xf3, 0xed, 0xd2, 0xfd, 0xdf, 0x0d, 0xa8, 0x15, 0xf2, 0xa3, 0x23, 0x80, 0xe9, 0xc6, 0x81, 0x5e,
	0xb5, 0x1e, 0xe4, 0xac, 0x4e, 0xb6, 0x94, 0x6c, 0xfc, 0x4f, 0xb6, 0x5c, 0x5b, 0x0e, 0xc1, 0x94,
	0xcf, 0x31, 0x7a, 0xeb, 0x55, 0x31, 0x0c, 0xe7, 0xb9, 0xdf, 0xfc, 0x4f, 0x9e, 0xf0, 0x93, 0xed,
	0xcd, 0x5f, 0x27, 0x2b, 0xc6, 0x9f, 0x93, 0x15, 0xe3, 0xaf, 0xc9, 0x8a, 0xf1, 0xf5, 0x2d, 0x1d,
	0x12, 0x91, 0xe1, 0xb1, 0x5e, 0x2f, 0x37, 0x47, 0x7c, 0x53, 0x9c, 0x8c, 0x36, 0xf3, 0x35, 0x73,
	0x30, 0xa7, 0x56, 0xc8, 0x07, 0xff, 0x04, 0x00, 0x00, 0xff, 0xff, 0x4c, 0x05, 0xb8, 0x53, 0x89,
	0x0a, 0x00, 0x00,
}

func (m *PushServiceReceiver) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceReceiver) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceReceiver) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.RecipientPublicKey) > 0 {
		i -= len(m.RecipientPublicKey)
		copy(dAtA[i:], m.RecipientPublicKey)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.RecipientPublicKey)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.BundleID) > 0 {
		i -= len(m.BundleID)
		copy(dAtA[i:], m.BundleID)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.BundleID)))
		i--
		dAtA[i] = 0x12
	}
	if m.TokenType != 0 {
		i = encodeVarintBertypushtypes(dAtA, i, uint64(m.TokenType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *PushServiceServerInfo) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceServerInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceServerInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *PushServiceServerInfo_Request) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceServerInfo_Request) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceServerInfo_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *PushServiceServerInfo_Reply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceServerInfo_Reply) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceServerInfo_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.SupportedTokenTypes) > 0 {
		for iNdEx := len(m.SupportedTokenTypes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.SupportedTokenTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBertypushtypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.PublicKey)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PushServiceSupportedTokenType) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceSupportedTokenType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceSupportedTokenType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.TokenType != 0 {
		i = encodeVarintBertypushtypes(dAtA, i, uint64(m.TokenType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.AppBundleID) > 0 {
		i -= len(m.AppBundleID)
		copy(dAtA[i:], m.AppBundleID)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.AppBundleID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PushServiceSend) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceSend) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceSend) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *PushServiceSend_Request) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceSend_Request) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceSend_Request) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Receivers) > 0 {
		for iNdEx := len(m.Receivers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Receivers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintBertypushtypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Priority != 0 {
		i = encodeVarintBertypushtypes(dAtA, i, uint64(m.Priority))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Envelope) > 0 {
		i -= len(m.Envelope)
		copy(dAtA[i:], m.Envelope)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.Envelope)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PushServiceSend_Reply) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceSend_Reply) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceSend_Reply) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *OutOfStoreExposedData) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *OutOfStoreExposedData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutOfStoreExposedData) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Box) > 0 {
		i -= len(m.Box)
		copy(dAtA[i:], m.Box)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.Box)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Nonce) > 0 {
		i -= len(m.Nonce)
		copy(dAtA[i:], m.Nonce)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.Nonce)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PushServiceOpaqueReceiver) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *PushServiceOpaqueReceiver) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushServiceOpaqueReceiver) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ServiceAddr) > 0 {
		i -= len(m.ServiceAddr)
		copy(dAtA[i:], m.ServiceAddr)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.ServiceAddr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.OpaqueToken) > 0 {
		i -= len(m.OpaqueToken)
		copy(dAtA[i:], m.OpaqueToken)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.OpaqueToken)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DecryptedPush) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *DecryptedPush) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DecryptedPush) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.HidePreview {
		i--
		if m.HidePreview {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x68
	}
	if m.ConversationMuted {
		i--
		if m.ConversationMuted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x60
	}
	if m.AccountMuted {
		i--
		if m.AccountMuted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x58
	}
	if m.AlreadyReceived {
		i--
		if m.AlreadyReceived {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if len(m.DeepLink) > 0 {
		i -= len(m.DeepLink)
		copy(dAtA[i:], m.DeepLink)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.DeepLink)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.PayloadAttrsJSON) > 0 {
		i -= len(m.PayloadAttrsJSON)
		copy(dAtA[i:], m.PayloadAttrsJSON)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.PayloadAttrsJSON)))
		i--
		dAtA[i] = 0x42
	}
	if m.PushType != 0 {
		i = encodeVarintBertypushtypes(dAtA, i, uint64(m.PushType))
		i--
		dAtA[i] = 0x38
	}
	if len(m.MemberDisplayName) > 0 {
		i -= len(m.MemberDisplayName)
		copy(dAtA[i:], m.MemberDisplayName)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.MemberDisplayName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.MemberPublicKey) > 0 {
		i -= len(m.MemberPublicKey)
		copy(dAtA[i:], m.MemberPublicKey)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.MemberPublicKey)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.ConversationDisplayName) > 0 {
		i -= len(m.ConversationDisplayName)
		copy(dAtA[i:], m.ConversationDisplayName)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.ConversationDisplayName)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ConversationPublicKey) > 0 {
		i -= len(m.ConversationPublicKey)
		copy(dAtA[i:], m.ConversationPublicKey)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.ConversationPublicKey)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.AccountName) > 0 {
		i -= len(m.AccountName)
		copy(dAtA[i:], m.AccountName)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.AccountName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.AccountID) > 0 {
		i -= len(m.AccountID)
		copy(dAtA[i:], m.AccountID)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.AccountID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FormatedPush) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FormatedPush) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FormatedPush) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ConversationIdentifier) > 0 {
		i -= len(m.ConversationIdentifier)
		copy(dAtA[i:], m.ConversationIdentifier)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.ConversationIdentifier)))
		i--
		dAtA[i] = 0x42
	}
	if m.HidePreview {
		i--
		if m.HidePreview {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Muted {
		i--
		if m.Muted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if len(m.DeepLink) > 0 {
		i -= len(m.DeepLink)
		copy(dAtA[i:], m.DeepLink)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.DeepLink)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Body) > 0 {
		i -= len(m.Body)
		copy(dAtA[i:], m.Body)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.Body)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Subtitle) > 0 {
		i -= len(m.Subtitle)
		copy(dAtA[i:], m.Subtitle)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.Subtitle)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Title) > 0 {
		i -= len(m.Title)
		copy(dAtA[i:], m.Title)
		i = encodeVarintBertypushtypes(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0x12
	}
	if m.PushType != 0 {
		i = encodeVarintBertypushtypes(dAtA, i, uint64(m.PushType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintBertypushtypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovBertypushtypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *PushServiceReceiver) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TokenType != 0 {
		n += 1 + sovBertypushtypes(uint64(m.TokenType))
	}
	l = len(m.BundleID)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.RecipientPublicKey)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushServiceServerInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushServiceServerInfo_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushServiceServerInfo_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.PublicKey)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if len(m.SupportedTokenTypes) > 0 {
		for _, e := range m.SupportedTokenTypes {
			l = e.Size()
			n += 1 + l + sovBertypushtypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushServiceSupportedTokenType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AppBundleID)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.TokenType != 0 {
		n += 1 + sovBertypushtypes(uint64(m.TokenType))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushServiceSend) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushServiceSend_Request) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Envelope)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.Priority != 0 {
		n += 1 + sovBertypushtypes(uint64(m.Priority))
	}
	if len(m.Receivers) > 0 {
		for _, e := range m.Receivers {
			l = e.Size()
			n += 1 + l + sovBertypushtypes(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushServiceSend_Reply) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *OutOfStoreExposedData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Nonce)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.Box)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushServiceOpaqueReceiver) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.OpaqueToken)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.ServiceAddr)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DecryptedPush) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.AccountID)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.ConversationPublicKey)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.ConversationDisplayName)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.MemberPublicKey)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.MemberDisplayName)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.PushType != 0 {
		n += 1 + sovBertypushtypes(uint64(m.PushType))
	}
	l = len(m.PayloadAttrsJSON)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.DeepLink)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.AlreadyReceived {
		n += 2
	}
	if m.AccountMuted {
		n += 2
	}
	if m.ConversationMuted {
		n += 2
	}
	if m.HidePreview {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *FormatedPush) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.PushType != 0 {
		n += 1 + sovBertypushtypes(uint64(m.PushType))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.Subtitle)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.Body)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	l = len(m.DeepLink)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.Muted {
		n += 2
	}
	if m.HidePreview {
		n += 2
	}
	l = len(m.ConversationIdentifier)
	if l > 0 {
		n += 1 + l + sovBertypushtypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovBertypushtypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozBertypushtypes(x uint64) (n int) {
	return sovBertypushtypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *PushServiceReceiver) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PushServiceReceiver: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushServiceReceiver: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenType", wireType)
			}
			m.TokenType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TokenType |= PushServiceTokenType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field BundleID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.BundleID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = append(m.Token[:0], dAtA[iNdEx:postIndex]...)
			if m.Token == nil {
				m.Token = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RecipientPublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RecipientPublicKey = append(m.RecipientPublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.RecipientPublicKey == nil {
				m.RecipientPublicKey = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushServiceServerInfo) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PushServiceServerInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushServiceServerInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushServiceServerInfo_Request) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushServiceServerInfo_Reply) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Reply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Reply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicKey", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicKey = append(m.PublicKey[:0], dAtA[iNdEx:postIndex]...)
			if m.PublicKey == nil {
				m.PublicKey = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SupportedTokenTypes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SupportedTokenTypes = append(m.SupportedTokenTypes, &PushServiceSupportedTokenType{})
			if err := m.SupportedTokenTypes[len(m.SupportedTokenTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushServiceSupportedTokenType) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PushServiceSupportedTokenType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushServiceSupportedTokenType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppBundleID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppBundleID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TokenType", wireType)
			}
			m.TokenType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TokenType |= PushServiceTokenType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushServiceSend) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PushServiceSend: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushServiceSend: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushServiceSend_Request) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Request: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Envelope", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Envelope = append(m.Envelope[:0], dAtA[iNdEx:postIndex]...)
			if m.Envelope == nil {
				m.Envelope = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
			}
			m.Priority = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Priority |= PushServicePriority(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Receivers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Receivers = append(m.Receivers, &PushServiceOpaqueReceiver{})
			if err := m.Receivers[len(m.Receivers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushServiceSend_Reply) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Reply: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Reply: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OutOfStoreExposedData) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: OutOfStoreExposedData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutOfStoreExposedData: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nonce", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nonce = append(m.Nonce[:0], dAtA[iNdEx:postIndex]...)
			if m.Nonce == nil {
				m.Nonce = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Box", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Box = append(m.Box[:0], dAtA[iNdEx:postIndex]...)
			if m.Box == nil {
				m.Box = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *PushServiceOpaqueReceiver) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: PushServiceOpaqueReceiver: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushServiceOpaqueReceiver: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OpaqueToken", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OpaqueToken = append(m.OpaqueToken[:0], dAtA[iNdEx:postIndex]...)
			if m.OpaqueToken == nil {
				m.OpaqueToken = []byte{}
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceAddr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DecryptedPush) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: DecryptedPush: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DecryptedPush: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AccountName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConversationPublicKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConversationPublicKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConversationDisplayName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConversationDisplayName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemberPublicKey", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MemberPublicKey = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemberDisplayName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MemberDisplayName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PushType", wireType)
			}
			m.PushType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PushType |= DecryptedPush_PushType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PayloadAttrsJSON", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PayloadAttrsJSON = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeepLink", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeepLink = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AlreadyReceived", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AlreadyReceived = bool(v != 0)
		case 11:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountMuted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AccountMuted = bool(v != 0)
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConversationMuted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ConversationMuted = bool(v != 0)
		case 13:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HidePreview", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HidePreview = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FormatedPush) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FormatedPush: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FormatedPush: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PushType", wireType)
			}
			m.PushType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PushType |= DecryptedPush_PushType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subtitle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Subtitle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Body", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Body = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DeepLink", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeepLink = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Muted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Muted = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field HidePreview", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.HidePreview = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConversationIdentifier", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConversationIdentifier = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipBertypushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthBertypushtypes
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipBertypushtypes(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowBertypushtypes
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowBertypushtypes
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthBertypushtypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupBertypushtypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthBertypushtypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthBertypushtypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowBertypushtypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupBertypushtypes = fmt.Errorf("proto: unexpected end of group")
)