pushtypes.pb.go

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

package pushtypes

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ = proto.Marshal
	_ = fmt.Errorf
	_ = 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_c5d464d796a95f49, []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_c5d464d796a95f49, []int{1}
}

type DecryptedPush_PushType int32

const (
	DecryptedPush_Unknown                 DecryptedPush_PushType = 0
	DecryptedPush_Message                 DecryptedPush_PushType = 1
	DecryptedPush_Reaction                DecryptedPush_PushType = 2
	DecryptedPush_Media                   DecryptedPush_PushType = 3
	DecryptedPush_Photo                   DecryptedPush_PushType = 4
	DecryptedPush_Gif                     DecryptedPush_PushType = 5
	DecryptedPush_VoiceMessage            DecryptedPush_PushType = 6
	DecryptedPush_GroupInvitation         DecryptedPush_PushType = 7
	DecryptedPush_ConversationNameChanged DecryptedPush_PushType = 8
	DecryptedPush_MemberNameChanged       DecryptedPush_PushType = 9
	DecryptedPush_MemberPictureChanged    DecryptedPush_PushType = 10
	DecryptedPush_MemberDetailsChanged    DecryptedPush_PushType = 11
	DecryptedPush_ReplyOptions            DecryptedPush_PushType = 12
)

var DecryptedPush_PushType_name = map[int32]string{
	0:  "Unknown",
	1:  "Message",
	2:  "Reaction",
	3:  "Media",
	4:  "Photo",
	5:  "Gif",
	6:  "VoiceMessage",
	7:  "GroupInvitation",
	8:  "ConversationNameChanged",
	9:  "MemberNameChanged",
	10: "MemberPictureChanged",
	11: "MemberDetailsChanged",
	12: "ReplyOptions",
}

var DecryptedPush_PushType_value = map[string]int32{
	"Unknown":                 0,
	"Message":                 1,
	"Reaction":                2,
	"Media":                   3,
	"Photo":                   4,
	"Gif":                     5,
	"VoiceMessage":            6,
	"GroupInvitation":         7,
	"ConversationNameChanged": 8,
	"MemberNameChanged":       9,
	"MemberPictureChanged":    10,
	"MemberDetailsChanged":    11,
	"ReplyOptions":            12,
}

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

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

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_c5d464d796a95f49, []int{0}
}

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_c5d464d796a95f49, []int{0, 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_c5d464d796a95f49, []int{0, 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_c5d464d796a95f49, []int{1}
}

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_c5d464d796a95f49, []int{2}
}

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             *OutOfStoreMessageEnvelope   `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_c5d464d796a95f49, []int{2, 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() *OutOfStoreMessageEnvelope {
	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_c5d464d796a95f49, []int{2, 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 OutOfStoreMessageEnvelope 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"`
	GroupReference       []byte   `protobuf:"bytes,4,opt,name=group_reference,json=groupReference,proto3" json:"group_reference,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *OutOfStoreMessageEnvelope) Reset()         { *m = OutOfStoreMessageEnvelope{} }
func (m *OutOfStoreMessageEnvelope) String() string { return proto.CompactTextString(m) }
func (*OutOfStoreMessageEnvelope) ProtoMessage()    {}
func (*OutOfStoreMessageEnvelope) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5d464d796a95f49, []int{3}
}

func (m *OutOfStoreMessageEnvelope) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *OutOfStoreMessageEnvelope) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OutOfStoreMessageEnvelope.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 *OutOfStoreMessageEnvelope) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OutOfStoreMessageEnvelope.Merge(m, src)
}

func (m *OutOfStoreMessageEnvelope) XXX_Size() int {
	return m.Size()
}

func (m *OutOfStoreMessageEnvelope) XXX_DiscardUnknown() {
	xxx_messageInfo_OutOfStoreMessageEnvelope.DiscardUnknown(m)
}

var xxx_messageInfo_OutOfStoreMessageEnvelope proto.InternalMessageInfo

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

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

func (m *OutOfStoreMessageEnvelope) GetGroupReference() []byte {
	if m != nil {
		return m.GroupReference
	}
	return nil
}

type PushExposedData 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 *PushExposedData) Reset()         { *m = PushExposedData{} }
func (m *PushExposedData) String() string { return proto.CompactTextString(m) }
func (*PushExposedData) ProtoMessage()    {}
func (*PushExposedData) Descriptor() ([]byte, []int) {
	return fileDescriptor_c5d464d796a95f49, []int{4}
}

func (m *PushExposedData) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}

func (m *PushExposedData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_PushExposedData.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 *PushExposedData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PushExposedData.Merge(m, src)
}

func (m *PushExposedData) XXX_Size() int {
	return m.Size()
}

func (m *PushExposedData) XXX_DiscardUnknown() {
	xxx_messageInfo_PushExposedData.DiscardUnknown(m)
}

var xxx_messageInfo_PushExposedData proto.InternalMessageInfo

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

func (m *PushExposedData) 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_c5d464d796a95f49, []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"`
	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_c5d464d796a95f49, []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
}

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"`
	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_c5d464d796a95f49, []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 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((*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((*OutOfStoreMessageEnvelope)(nil), "berty.push.v1.OutOfStoreMessageEnvelope")
	proto.RegisterType((*PushExposedData)(nil), "berty.push.v1.PushExposedData")
	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.proto", fileDescriptor_c5d464d796a95f49) }

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

// Reference imports to suppress errors if they are not otherwise used.
var (
	_ context.Context
	_ grpc.ClientConn
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// PushServiceClient is the client API for PushService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PushServiceClient interface {
	// ServerInfo retrieves metadata about the current push service
	ServerInfo(ctx context.Context, in *PushServiceServerInfo_Request, opts ...grpc.CallOption) (*PushServiceServerInfo_Reply, error)
	// Send dispatch a push payload to one or multiple recipients
	Send(ctx context.Context, in *PushServiceSend_Request, opts ...grpc.CallOption) (*PushServiceSend_Reply, error)
}

type pushServiceClient struct {
	cc *grpc.ClientConn
}

func NewPushServiceClient(cc *grpc.ClientConn) PushServiceClient {
	return &pushServiceClient{cc}
}

func (c *pushServiceClient) ServerInfo(ctx context.Context, in *PushServiceServerInfo_Request, opts ...grpc.CallOption) (*PushServiceServerInfo_Reply, error) {
	out := new(PushServiceServerInfo_Reply)
	err := c.cc.Invoke(ctx, "/berty.push.v1.PushService/ServerInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *pushServiceClient) Send(ctx context.Context, in *PushServiceSend_Request, opts ...grpc.CallOption) (*PushServiceSend_Reply, error) {
	out := new(PushServiceSend_Reply)
	err := c.cc.Invoke(ctx, "/berty.push.v1.PushService/Send", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PushServiceServer is the server API for PushService service.
type PushServiceServer interface {
	// ServerInfo retrieves metadata about the current push service
	ServerInfo(context.Context, *PushServiceServerInfo_Request) (*PushServiceServerInfo_Reply, error)
	// Send dispatch a push payload to one or multiple recipients
	Send(context.Context, *PushServiceSend_Request) (*PushServiceSend_Reply, error)
}

// UnimplementedPushServiceServer can be embedded to have forward compatible implementations.
type UnimplementedPushServiceServer struct{}

func (*UnimplementedPushServiceServer) ServerInfo(ctx context.Context, req *PushServiceServerInfo_Request) (*PushServiceServerInfo_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ServerInfo not implemented")
}

func (*UnimplementedPushServiceServer) Send(ctx context.Context, req *PushServiceSend_Request) (*PushServiceSend_Reply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Send not implemented")
}

func RegisterPushServiceServer(s *grpc.Server, srv PushServiceServer) {
	s.RegisterService(&_PushService_serviceDesc, srv)
}

func _PushService_ServerInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PushServiceServerInfo_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServiceServer).ServerInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.push.v1.PushService/ServerInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServiceServer).ServerInfo(ctx, req.(*PushServiceServerInfo_Request))
	}
	return interceptor(ctx, in, info, handler)
}

func _PushService_Send_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PushServiceSend_Request)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PushServiceServer).Send(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/berty.push.v1.PushService/Send",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PushServiceServer).Send(ctx, req.(*PushServiceSend_Request))
	}
	return interceptor(ctx, in, info, handler)
}

var _PushService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "berty.push.v1.PushService",
	HandlerType: (*PushServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ServerInfo",
			Handler:    _PushService_ServerInfo_Handler,
		},
		{
			MethodName: "Send",
			Handler:    _PushService_Send_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pushtypes.proto",
}

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 = encodeVarintPushtypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.PublicKey) > 0 {
		i -= len(m.PublicKey)
		copy(dAtA[i:], m.PublicKey)
		i = encodeVarintPushtypes(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 = encodeVarintPushtypes(dAtA, i, uint64(m.TokenType))
		i--
		dAtA[i] = 0x10
	}
	if len(m.AppBundleID) > 0 {
		i -= len(m.AppBundleID)
		copy(dAtA[i:], m.AppBundleID)
		i = encodeVarintPushtypes(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 = encodeVarintPushtypes(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Priority != 0 {
		i = encodeVarintPushtypes(dAtA, i, uint64(m.Priority))
		i--
		dAtA[i] = 0x10
	}
	if m.Envelope != nil {
		{
			size, err := m.Envelope.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintPushtypes(dAtA, i, uint64(size))
		}
		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 *OutOfStoreMessageEnvelope) 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 *OutOfStoreMessageEnvelope) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OutOfStoreMessageEnvelope) 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.GroupReference) > 0 {
		i -= len(m.GroupReference)
		copy(dAtA[i:], m.GroupReference)
		i = encodeVarintPushtypes(dAtA, i, uint64(len(m.GroupReference)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Box) > 0 {
		i -= len(m.Box)
		copy(dAtA[i:], m.Box)
		i = encodeVarintPushtypes(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 = encodeVarintPushtypes(dAtA, i, uint64(len(m.Nonce)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *PushExposedData) 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 *PushExposedData) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *PushExposedData) 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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(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.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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(dAtA, i, uint64(len(m.PayloadAttrsJSON)))
		i--
		dAtA[i] = 0x42
	}
	if m.PushType != 0 {
		i = encodeVarintPushtypes(dAtA, i, uint64(m.PushType))
		i--
		dAtA[i] = 0x38
	}
	if len(m.MemberDisplayName) > 0 {
		i -= len(m.MemberDisplayName)
		copy(dAtA[i:], m.MemberDisplayName)
		i = encodeVarintPushtypes(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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(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.DeepLink) > 0 {
		i -= len(m.DeepLink)
		copy(dAtA[i:], m.DeepLink)
		i = encodeVarintPushtypes(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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(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 = encodeVarintPushtypes(dAtA, i, uint64(len(m.Title)))
		i--
		dAtA[i] = 0x12
	}
	if m.PushType != 0 {
		i = encodeVarintPushtypes(dAtA, i, uint64(m.PushType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintPushtypes(dAtA []byte, offset int, v uint64) int {
	offset -= sovPushtypes(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}

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 + sovPushtypes(uint64(l))
	}
	if len(m.SupportedTokenTypes) > 0 {
		for _, e := range m.SupportedTokenTypes {
			l = e.Size()
			n += 1 + l + sovPushtypes(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 + sovPushtypes(uint64(l))
	}
	if m.TokenType != 0 {
		n += 1 + sovPushtypes(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
	if m.Envelope != nil {
		l = m.Envelope.Size()
		n += 1 + l + sovPushtypes(uint64(l))
	}
	if m.Priority != 0 {
		n += 1 + sovPushtypes(uint64(m.Priority))
	}
	if len(m.Receivers) > 0 {
		for _, e := range m.Receivers {
			l = e.Size()
			n += 1 + l + sovPushtypes(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 *OutOfStoreMessageEnvelope) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Nonce)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.Box)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.GroupReference)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *PushExposedData) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Nonce)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.Box)
	if l > 0 {
		n += 1 + l + sovPushtypes(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 + sovPushtypes(uint64(l))
	}
	l = len(m.ServiceAddr)
	if l > 0 {
		n += 1 + l + sovPushtypes(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 + sovPushtypes(uint64(l))
	}
	l = len(m.AccountName)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.ConversationPublicKey)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.ConversationDisplayName)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.MemberPublicKey)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.MemberDisplayName)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	if m.PushType != 0 {
		n += 1 + sovPushtypes(uint64(m.PushType))
	}
	l = len(m.PayloadAttrsJSON)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.DeepLink)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	if m.AlreadyReceived {
		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 + sovPushtypes(uint64(m.PushType))
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.Subtitle)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.Body)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	l = len(m.DeepLink)
	if l > 0 {
		n += 1 + l + sovPushtypes(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovPushtypes(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}

func sozPushtypes(x uint64) (n int) {
	return sovPushtypes(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}

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 ErrIntOverflowPushtypes
			}
			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 := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Envelope == nil {
				m.Envelope = &OutOfStoreMessageEnvelope{}
			}
			if err := m.Envelope.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 *OutOfStoreMessageEnvelope) 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 ErrIntOverflowPushtypes
			}
			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: OutOfStoreMessageEnvelope: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OutOfStoreMessageEnvelope: 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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Box = append(m.Box[:0], dAtA[iNdEx:postIndex]...)
			if m.Box == nil {
				m.Box = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GroupReference", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.GroupReference = append(m.GroupReference[:0], dAtA[iNdEx:postIndex]...)
			if m.GroupReference == nil {
				m.GroupReference = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 *PushExposedData) 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 ErrIntOverflowPushtypes
			}
			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: PushExposedData: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: PushExposedData: 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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceAddr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.AlreadyReceived = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 ErrIntOverflowPushtypes
				}
				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 ErrInvalidLengthPushtypes
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthPushtypes
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DeepLink = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipPushtypes(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthPushtypes
			}
			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 skipPushtypes(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, ErrIntOverflowPushtypes
			}
			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, ErrIntOverflowPushtypes
				}
				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, ErrIntOverflowPushtypes
				}
				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, ErrInvalidLengthPushtypes
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupPushtypes
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthPushtypes
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthPushtypes        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowPushtypes          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupPushtypes = fmt.Errorf("proto: unexpected end of group")
)