// Code generated by protoc-gen-go. DO NOT EDIT.
// source: third/third.proto

package third // import "OpenIM/pkg/proto/third"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import sdkws "OpenIM/pkg/proto/sdkws"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

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

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

type ApplyPutReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Size                 int64    `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	Hash                 string   `protobuf:"bytes,3,opt,name=hash" json:"hash,omitempty"`
	FragmentSize         int64    `protobuf:"varint,4,opt,name=fragmentSize" json:"fragmentSize,omitempty"`
	CleanTime            int64    `protobuf:"varint,5,opt,name=cleanTime" json:"cleanTime,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ApplyPutReq) Reset()         { *m = ApplyPutReq{} }
func (m *ApplyPutReq) String() string { return proto.CompactTextString(m) }
func (*ApplyPutReq) ProtoMessage()    {}
func (*ApplyPutReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{0}
}
func (m *ApplyPutReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ApplyPutReq.Unmarshal(m, b)
}
func (m *ApplyPutReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ApplyPutReq.Marshal(b, m, deterministic)
}
func (dst *ApplyPutReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplyPutReq.Merge(dst, src)
}
func (m *ApplyPutReq) XXX_Size() int {
	return xxx_messageInfo_ApplyPutReq.Size(m)
}
func (m *ApplyPutReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplyPutReq.DiscardUnknown(m)
}

var xxx_messageInfo_ApplyPutReq proto.InternalMessageInfo

func (m *ApplyPutReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *ApplyPutReq) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *ApplyPutReq) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *ApplyPutReq) GetFragmentSize() int64 {
	if m != nil {
		return m.FragmentSize
	}
	return 0
}

func (m *ApplyPutReq) GetCleanTime() int64 {
	if m != nil {
		return m.CleanTime
	}
	return 0
}

type ApplyPutResp struct {
	Url          string `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"`
	PutID        string `protobuf:"bytes,2,opt,name=putID" json:"putID,omitempty"`
	FragmentSize int64  `protobuf:"varint,3,opt,name=fragmentSize" json:"fragmentSize,omitempty"`
	//  int64 expirationTime = 4;
	PutURLs              []string `protobuf:"bytes,5,rep,name=PutURLs" json:"PutURLs,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ApplyPutResp) Reset()         { *m = ApplyPutResp{} }
func (m *ApplyPutResp) String() string { return proto.CompactTextString(m) }
func (*ApplyPutResp) ProtoMessage()    {}
func (*ApplyPutResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{1}
}
func (m *ApplyPutResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ApplyPutResp.Unmarshal(m, b)
}
func (m *ApplyPutResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ApplyPutResp.Marshal(b, m, deterministic)
}
func (dst *ApplyPutResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ApplyPutResp.Merge(dst, src)
}
func (m *ApplyPutResp) XXX_Size() int {
	return xxx_messageInfo_ApplyPutResp.Size(m)
}
func (m *ApplyPutResp) XXX_DiscardUnknown() {
	xxx_messageInfo_ApplyPutResp.DiscardUnknown(m)
}

var xxx_messageInfo_ApplyPutResp proto.InternalMessageInfo

func (m *ApplyPutResp) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *ApplyPutResp) GetPutID() string {
	if m != nil {
		return m.PutID
	}
	return ""
}

func (m *ApplyPutResp) GetFragmentSize() int64 {
	if m != nil {
		return m.FragmentSize
	}
	return 0
}

func (m *ApplyPutResp) GetPutURLs() []string {
	if m != nil {
		return m.PutURLs
	}
	return nil
}

type ConfirmPutReq struct {
	PutID                string   `protobuf:"bytes,1,opt,name=putID" json:"putID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConfirmPutReq) Reset()         { *m = ConfirmPutReq{} }
func (m *ConfirmPutReq) String() string { return proto.CompactTextString(m) }
func (*ConfirmPutReq) ProtoMessage()    {}
func (*ConfirmPutReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{2}
}
func (m *ConfirmPutReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConfirmPutReq.Unmarshal(m, b)
}
func (m *ConfirmPutReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConfirmPutReq.Marshal(b, m, deterministic)
}
func (dst *ConfirmPutReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfirmPutReq.Merge(dst, src)
}
func (m *ConfirmPutReq) XXX_Size() int {
	return xxx_messageInfo_ConfirmPutReq.Size(m)
}
func (m *ConfirmPutReq) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfirmPutReq.DiscardUnknown(m)
}

var xxx_messageInfo_ConfirmPutReq proto.InternalMessageInfo

func (m *ConfirmPutReq) GetPutID() string {
	if m != nil {
		return m.PutID
	}
	return ""
}

type ConfirmPutResp struct {
	Url                  string   `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConfirmPutResp) Reset()         { *m = ConfirmPutResp{} }
func (m *ConfirmPutResp) String() string { return proto.CompactTextString(m) }
func (*ConfirmPutResp) ProtoMessage()    {}
func (*ConfirmPutResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{3}
}
func (m *ConfirmPutResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConfirmPutResp.Unmarshal(m, b)
}
func (m *ConfirmPutResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConfirmPutResp.Marshal(b, m, deterministic)
}
func (dst *ConfirmPutResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConfirmPutResp.Merge(dst, src)
}
func (m *ConfirmPutResp) XXX_Size() int {
	return xxx_messageInfo_ConfirmPutResp.Size(m)
}
func (m *ConfirmPutResp) XXX_DiscardUnknown() {
	xxx_messageInfo_ConfirmPutResp.DiscardUnknown(m)
}

var xxx_messageInfo_ConfirmPutResp proto.InternalMessageInfo

func (m *ConfirmPutResp) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

type GetUrlReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetUrlReq) Reset()         { *m = GetUrlReq{} }
func (m *GetUrlReq) String() string { return proto.CompactTextString(m) }
func (*GetUrlReq) ProtoMessage()    {}
func (*GetUrlReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{4}
}
func (m *GetUrlReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetUrlReq.Unmarshal(m, b)
}
func (m *GetUrlReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetUrlReq.Marshal(b, m, deterministic)
}
func (dst *GetUrlReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetUrlReq.Merge(dst, src)
}
func (m *GetUrlReq) XXX_Size() int {
	return xxx_messageInfo_GetUrlReq.Size(m)
}
func (m *GetUrlReq) XXX_DiscardUnknown() {
	xxx_messageInfo_GetUrlReq.DiscardUnknown(m)
}

var xxx_messageInfo_GetUrlReq proto.InternalMessageInfo

func (m *GetUrlReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type GetUrlResp struct {
	Url                  string   `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"`
	Size                 int64    `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	Hash                 string   `protobuf:"bytes,3,opt,name=hash" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetUrlResp) Reset()         { *m = GetUrlResp{} }
func (m *GetUrlResp) String() string { return proto.CompactTextString(m) }
func (*GetUrlResp) ProtoMessage()    {}
func (*GetUrlResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{5}
}
func (m *GetUrlResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetUrlResp.Unmarshal(m, b)
}
func (m *GetUrlResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetUrlResp.Marshal(b, m, deterministic)
}
func (dst *GetUrlResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetUrlResp.Merge(dst, src)
}
func (m *GetUrlResp) XXX_Size() int {
	return xxx_messageInfo_GetUrlResp.Size(m)
}
func (m *GetUrlResp) XXX_DiscardUnknown() {
	xxx_messageInfo_GetUrlResp.DiscardUnknown(m)
}

var xxx_messageInfo_GetUrlResp proto.InternalMessageInfo

func (m *GetUrlResp) GetUrl() string {
	if m != nil {
		return m.Url
	}
	return ""
}

func (m *GetUrlResp) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *GetUrlResp) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

type GetPutReq struct {
	PutID                string   `protobuf:"bytes,1,opt,name=putID" json:"putID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetPutReq) Reset()         { *m = GetPutReq{} }
func (m *GetPutReq) String() string { return proto.CompactTextString(m) }
func (*GetPutReq) ProtoMessage()    {}
func (*GetPutReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{6}
}
func (m *GetPutReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetPutReq.Unmarshal(m, b)
}
func (m *GetPutReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetPutReq.Marshal(b, m, deterministic)
}
func (dst *GetPutReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPutReq.Merge(dst, src)
}
func (m *GetPutReq) XXX_Size() int {
	return xxx_messageInfo_GetPutReq.Size(m)
}
func (m *GetPutReq) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPutReq.DiscardUnknown(m)
}

var xxx_messageInfo_GetPutReq proto.InternalMessageInfo

func (m *GetPutReq) GetPutID() string {
	if m != nil {
		return m.PutID
	}
	return ""
}

type GetPutFragment struct {
	Size                 int64    `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
	Hash                 string   `protobuf:"bytes,2,opt,name=hash" json:"hash,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetPutFragment) Reset()         { *m = GetPutFragment{} }
func (m *GetPutFragment) String() string { return proto.CompactTextString(m) }
func (*GetPutFragment) ProtoMessage()    {}
func (*GetPutFragment) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{7}
}
func (m *GetPutFragment) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetPutFragment.Unmarshal(m, b)
}
func (m *GetPutFragment) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetPutFragment.Marshal(b, m, deterministic)
}
func (dst *GetPutFragment) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPutFragment.Merge(dst, src)
}
func (m *GetPutFragment) XXX_Size() int {
	return xxx_messageInfo_GetPutFragment.Size(m)
}
func (m *GetPutFragment) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPutFragment.DiscardUnknown(m)
}

var xxx_messageInfo_GetPutFragment proto.InternalMessageInfo

func (m *GetPutFragment) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *GetPutFragment) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

type GetPutResp struct {
	Name                 string            `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Size                 int64             `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	Hash                 string            `protobuf:"bytes,3,opt,name=hash" json:"hash,omitempty"`
	FragmentSize         int64             `protobuf:"varint,4,opt,name=fragmentSize" json:"fragmentSize,omitempty"`
	CleanTime            int64             `protobuf:"varint,5,opt,name=cleanTime" json:"cleanTime,omitempty"`
	Fragments            []*GetPutFragment `protobuf:"bytes,6,rep,name=fragments" json:"fragments,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *GetPutResp) Reset()         { *m = GetPutResp{} }
func (m *GetPutResp) String() string { return proto.CompactTextString(m) }
func (*GetPutResp) ProtoMessage()    {}
func (*GetPutResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{8}
}
func (m *GetPutResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetPutResp.Unmarshal(m, b)
}
func (m *GetPutResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetPutResp.Marshal(b, m, deterministic)
}
func (dst *GetPutResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetPutResp.Merge(dst, src)
}
func (m *GetPutResp) XXX_Size() int {
	return xxx_messageInfo_GetPutResp.Size(m)
}
func (m *GetPutResp) XXX_DiscardUnknown() {
	xxx_messageInfo_GetPutResp.DiscardUnknown(m)
}

var xxx_messageInfo_GetPutResp proto.InternalMessageInfo

func (m *GetPutResp) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *GetPutResp) GetSize() int64 {
	if m != nil {
		return m.Size
	}
	return 0
}

func (m *GetPutResp) GetHash() string {
	if m != nil {
		return m.Hash
	}
	return ""
}

func (m *GetPutResp) GetFragmentSize() int64 {
	if m != nil {
		return m.FragmentSize
	}
	return 0
}

func (m *GetPutResp) GetCleanTime() int64 {
	if m != nil {
		return m.CleanTime
	}
	return 0
}

func (m *GetPutResp) GetFragments() []*GetPutFragment {
	if m != nil {
		return m.Fragments
	}
	return nil
}

type GetSignalInvitationInfoReq struct {
	ClientMsgID          string   `protobuf:"bytes,1,opt,name=ClientMsgID" json:"ClientMsgID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetSignalInvitationInfoReq) Reset()         { *m = GetSignalInvitationInfoReq{} }
func (m *GetSignalInvitationInfoReq) String() string { return proto.CompactTextString(m) }
func (*GetSignalInvitationInfoReq) ProtoMessage()    {}
func (*GetSignalInvitationInfoReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{9}
}
func (m *GetSignalInvitationInfoReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetSignalInvitationInfoReq.Unmarshal(m, b)
}
func (m *GetSignalInvitationInfoReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetSignalInvitationInfoReq.Marshal(b, m, deterministic)
}
func (dst *GetSignalInvitationInfoReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetSignalInvitationInfoReq.Merge(dst, src)
}
func (m *GetSignalInvitationInfoReq) XXX_Size() int {
	return xxx_messageInfo_GetSignalInvitationInfoReq.Size(m)
}
func (m *GetSignalInvitationInfoReq) XXX_DiscardUnknown() {
	xxx_messageInfo_GetSignalInvitationInfoReq.DiscardUnknown(m)
}

var xxx_messageInfo_GetSignalInvitationInfoReq proto.InternalMessageInfo

func (m *GetSignalInvitationInfoReq) GetClientMsgID() string {
	if m != nil {
		return m.ClientMsgID
	}
	return ""
}

type GetSignalInvitationInfoResp struct {
	InvitationInfo       *sdkws.InvitationInfo  `protobuf:"bytes,1,opt,name=invitationInfo" json:"invitationInfo,omitempty"`
	OfflinePushInfo      *sdkws.OfflinePushInfo `protobuf:"bytes,2,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *GetSignalInvitationInfoResp) Reset()         { *m = GetSignalInvitationInfoResp{} }
func (m *GetSignalInvitationInfoResp) String() string { return proto.CompactTextString(m) }
func (*GetSignalInvitationInfoResp) ProtoMessage()    {}
func (*GetSignalInvitationInfoResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{10}
}
func (m *GetSignalInvitationInfoResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetSignalInvitationInfoResp.Unmarshal(m, b)
}
func (m *GetSignalInvitationInfoResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetSignalInvitationInfoResp.Marshal(b, m, deterministic)
}
func (dst *GetSignalInvitationInfoResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetSignalInvitationInfoResp.Merge(dst, src)
}
func (m *GetSignalInvitationInfoResp) XXX_Size() int {
	return xxx_messageInfo_GetSignalInvitationInfoResp.Size(m)
}
func (m *GetSignalInvitationInfoResp) XXX_DiscardUnknown() {
	xxx_messageInfo_GetSignalInvitationInfoResp.DiscardUnknown(m)
}

var xxx_messageInfo_GetSignalInvitationInfoResp proto.InternalMessageInfo

func (m *GetSignalInvitationInfoResp) GetInvitationInfo() *sdkws.InvitationInfo {
	if m != nil {
		return m.InvitationInfo
	}
	return nil
}

func (m *GetSignalInvitationInfoResp) GetOfflinePushInfo() *sdkws.OfflinePushInfo {
	if m != nil {
		return m.OfflinePushInfo
	}
	return nil
}

type GetSignalInvitationInfoStartAppReq struct {
	UserID               string   `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetSignalInvitationInfoStartAppReq) Reset()         { *m = GetSignalInvitationInfoStartAppReq{} }
func (m *GetSignalInvitationInfoStartAppReq) String() string { return proto.CompactTextString(m) }
func (*GetSignalInvitationInfoStartAppReq) ProtoMessage()    {}
func (*GetSignalInvitationInfoStartAppReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{11}
}
func (m *GetSignalInvitationInfoStartAppReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetSignalInvitationInfoStartAppReq.Unmarshal(m, b)
}
func (m *GetSignalInvitationInfoStartAppReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetSignalInvitationInfoStartAppReq.Marshal(b, m, deterministic)
}
func (dst *GetSignalInvitationInfoStartAppReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetSignalInvitationInfoStartAppReq.Merge(dst, src)
}
func (m *GetSignalInvitationInfoStartAppReq) XXX_Size() int {
	return xxx_messageInfo_GetSignalInvitationInfoStartAppReq.Size(m)
}
func (m *GetSignalInvitationInfoStartAppReq) XXX_DiscardUnknown() {
	xxx_messageInfo_GetSignalInvitationInfoStartAppReq.DiscardUnknown(m)
}

var xxx_messageInfo_GetSignalInvitationInfoStartAppReq proto.InternalMessageInfo

func (m *GetSignalInvitationInfoStartAppReq) GetUserID() string {
	if m != nil {
		return m.UserID
	}
	return ""
}

type GetSignalInvitationInfoStartAppResp struct {
	InvitationInfo       *sdkws.InvitationInfo  `protobuf:"bytes,1,opt,name=invitationInfo" json:"invitationInfo,omitempty"`
	OfflinePushInfo      *sdkws.OfflinePushInfo `protobuf:"bytes,2,opt,name=offlinePushInfo" json:"offlinePushInfo,omitempty"`
	XXX_NoUnkeyedLiteral struct{}               `json:"-"`
	XXX_unrecognized     []byte                 `json:"-"`
	XXX_sizecache        int32                  `json:"-"`
}

func (m *GetSignalInvitationInfoStartAppResp) Reset()         { *m = GetSignalInvitationInfoStartAppResp{} }
func (m *GetSignalInvitationInfoStartAppResp) String() string { return proto.CompactTextString(m) }
func (*GetSignalInvitationInfoStartAppResp) ProtoMessage()    {}
func (*GetSignalInvitationInfoStartAppResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{12}
}
func (m *GetSignalInvitationInfoStartAppResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetSignalInvitationInfoStartAppResp.Unmarshal(m, b)
}
func (m *GetSignalInvitationInfoStartAppResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetSignalInvitationInfoStartAppResp.Marshal(b, m, deterministic)
}
func (dst *GetSignalInvitationInfoStartAppResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetSignalInvitationInfoStartAppResp.Merge(dst, src)
}
func (m *GetSignalInvitationInfoStartAppResp) XXX_Size() int {
	return xxx_messageInfo_GetSignalInvitationInfoStartAppResp.Size(m)
}
func (m *GetSignalInvitationInfoStartAppResp) XXX_DiscardUnknown() {
	xxx_messageInfo_GetSignalInvitationInfoStartAppResp.DiscardUnknown(m)
}

var xxx_messageInfo_GetSignalInvitationInfoStartAppResp proto.InternalMessageInfo

func (m *GetSignalInvitationInfoStartAppResp) GetInvitationInfo() *sdkws.InvitationInfo {
	if m != nil {
		return m.InvitationInfo
	}
	return nil
}

func (m *GetSignalInvitationInfoStartAppResp) GetOfflinePushInfo() *sdkws.OfflinePushInfo {
	if m != nil {
		return m.OfflinePushInfo
	}
	return nil
}

type FcmUpdateTokenReq struct {
	PlatformID           int32    `protobuf:"varint,1,opt,name=PlatformID" json:"PlatformID,omitempty"`
	FcmToken             string   `protobuf:"bytes,2,opt,name=FcmToken" json:"FcmToken,omitempty"`
	Account              string   `protobuf:"bytes,3,opt,name=account" json:"account,omitempty"`
	ExpireTime           int64    `protobuf:"varint,4,opt,name=expireTime" json:"expireTime,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FcmUpdateTokenReq) Reset()         { *m = FcmUpdateTokenReq{} }
func (m *FcmUpdateTokenReq) String() string { return proto.CompactTextString(m) }
func (*FcmUpdateTokenReq) ProtoMessage()    {}
func (*FcmUpdateTokenReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{13}
}
func (m *FcmUpdateTokenReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FcmUpdateTokenReq.Unmarshal(m, b)
}
func (m *FcmUpdateTokenReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FcmUpdateTokenReq.Marshal(b, m, deterministic)
}
func (dst *FcmUpdateTokenReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FcmUpdateTokenReq.Merge(dst, src)
}
func (m *FcmUpdateTokenReq) XXX_Size() int {
	return xxx_messageInfo_FcmUpdateTokenReq.Size(m)
}
func (m *FcmUpdateTokenReq) XXX_DiscardUnknown() {
	xxx_messageInfo_FcmUpdateTokenReq.DiscardUnknown(m)
}

var xxx_messageInfo_FcmUpdateTokenReq proto.InternalMessageInfo

func (m *FcmUpdateTokenReq) GetPlatformID() int32 {
	if m != nil {
		return m.PlatformID
	}
	return 0
}

func (m *FcmUpdateTokenReq) GetFcmToken() string {
	if m != nil {
		return m.FcmToken
	}
	return ""
}

func (m *FcmUpdateTokenReq) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

func (m *FcmUpdateTokenReq) GetExpireTime() int64 {
	if m != nil {
		return m.ExpireTime
	}
	return 0
}

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

func (m *FcmUpdateTokenResp) Reset()         { *m = FcmUpdateTokenResp{} }
func (m *FcmUpdateTokenResp) String() string { return proto.CompactTextString(m) }
func (*FcmUpdateTokenResp) ProtoMessage()    {}
func (*FcmUpdateTokenResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{14}
}
func (m *FcmUpdateTokenResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FcmUpdateTokenResp.Unmarshal(m, b)
}
func (m *FcmUpdateTokenResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FcmUpdateTokenResp.Marshal(b, m, deterministic)
}
func (dst *FcmUpdateTokenResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FcmUpdateTokenResp.Merge(dst, src)
}
func (m *FcmUpdateTokenResp) XXX_Size() int {
	return xxx_messageInfo_FcmUpdateTokenResp.Size(m)
}
func (m *FcmUpdateTokenResp) XXX_DiscardUnknown() {
	xxx_messageInfo_FcmUpdateTokenResp.DiscardUnknown(m)
}

var xxx_messageInfo_FcmUpdateTokenResp proto.InternalMessageInfo

type SetAppBadgeReq struct {
	UserID               string   `protobuf:"bytes,1,opt,name=userID" json:"userID,omitempty"`
	AppUnreadCount       int32    `protobuf:"varint,2,opt,name=AppUnreadCount" json:"AppUnreadCount,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SetAppBadgeReq) Reset()         { *m = SetAppBadgeReq{} }
func (m *SetAppBadgeReq) String() string { return proto.CompactTextString(m) }
func (*SetAppBadgeReq) ProtoMessage()    {}
func (*SetAppBadgeReq) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{15}
}
func (m *SetAppBadgeReq) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetAppBadgeReq.Unmarshal(m, b)
}
func (m *SetAppBadgeReq) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetAppBadgeReq.Marshal(b, m, deterministic)
}
func (dst *SetAppBadgeReq) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetAppBadgeReq.Merge(dst, src)
}
func (m *SetAppBadgeReq) XXX_Size() int {
	return xxx_messageInfo_SetAppBadgeReq.Size(m)
}
func (m *SetAppBadgeReq) XXX_DiscardUnknown() {
	xxx_messageInfo_SetAppBadgeReq.DiscardUnknown(m)
}

var xxx_messageInfo_SetAppBadgeReq proto.InternalMessageInfo

func (m *SetAppBadgeReq) GetUserID() string {
	if m != nil {
		return m.UserID
	}
	return ""
}

func (m *SetAppBadgeReq) GetAppUnreadCount() int32 {
	if m != nil {
		return m.AppUnreadCount
	}
	return 0
}

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

func (m *SetAppBadgeResp) Reset()         { *m = SetAppBadgeResp{} }
func (m *SetAppBadgeResp) String() string { return proto.CompactTextString(m) }
func (*SetAppBadgeResp) ProtoMessage()    {}
func (*SetAppBadgeResp) Descriptor() ([]byte, []int) {
	return fileDescriptor_third_85db3e967ff9b8c1, []int{16}
}
func (m *SetAppBadgeResp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SetAppBadgeResp.Unmarshal(m, b)
}
func (m *SetAppBadgeResp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SetAppBadgeResp.Marshal(b, m, deterministic)
}
func (dst *SetAppBadgeResp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SetAppBadgeResp.Merge(dst, src)
}
func (m *SetAppBadgeResp) XXX_Size() int {
	return xxx_messageInfo_SetAppBadgeResp.Size(m)
}
func (m *SetAppBadgeResp) XXX_DiscardUnknown() {
	xxx_messageInfo_SetAppBadgeResp.DiscardUnknown(m)
}

var xxx_messageInfo_SetAppBadgeResp proto.InternalMessageInfo

func init() {
	proto.RegisterType((*ApplyPutReq)(nil), "OpenIMServer.third.ApplyPutReq")
	proto.RegisterType((*ApplyPutResp)(nil), "OpenIMServer.third.ApplyPutResp")
	proto.RegisterType((*ConfirmPutReq)(nil), "OpenIMServer.third.ConfirmPutReq")
	proto.RegisterType((*ConfirmPutResp)(nil), "OpenIMServer.third.ConfirmPutResp")
	proto.RegisterType((*GetUrlReq)(nil), "OpenIMServer.third.GetUrlReq")
	proto.RegisterType((*GetUrlResp)(nil), "OpenIMServer.third.GetUrlResp")
	proto.RegisterType((*GetPutReq)(nil), "OpenIMServer.third.GetPutReq")
	proto.RegisterType((*GetPutFragment)(nil), "OpenIMServer.third.GetPutFragment")
	proto.RegisterType((*GetPutResp)(nil), "OpenIMServer.third.GetPutResp")
	proto.RegisterType((*GetSignalInvitationInfoReq)(nil), "OpenIMServer.third.GetSignalInvitationInfoReq")
	proto.RegisterType((*GetSignalInvitationInfoResp)(nil), "OpenIMServer.third.GetSignalInvitationInfoResp")
	proto.RegisterType((*GetSignalInvitationInfoStartAppReq)(nil), "OpenIMServer.third.GetSignalInvitationInfoStartAppReq")
	proto.RegisterType((*GetSignalInvitationInfoStartAppResp)(nil), "OpenIMServer.third.GetSignalInvitationInfoStartAppResp")
	proto.RegisterType((*FcmUpdateTokenReq)(nil), "OpenIMServer.third.FcmUpdateTokenReq")
	proto.RegisterType((*FcmUpdateTokenResp)(nil), "OpenIMServer.third.FcmUpdateTokenResp")
	proto.RegisterType((*SetAppBadgeReq)(nil), "OpenIMServer.third.SetAppBadgeReq")
	proto.RegisterType((*SetAppBadgeResp)(nil), "OpenIMServer.third.SetAppBadgeResp")
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ 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

// Client API for Third service

type ThirdClient interface {
	ApplyPut(ctx context.Context, in *ApplyPutReq, opts ...grpc.CallOption) (*ApplyPutResp, error)
	GetPut(ctx context.Context, in *GetPutReq, opts ...grpc.CallOption) (*GetPutResp, error)
	ConfirmPut(ctx context.Context, in *ConfirmPutReq, opts ...grpc.CallOption) (*ConfirmPutResp, error)
	GetUrl(ctx context.Context, in *GetUrlReq, opts ...grpc.CallOption) (*GetUrlResp, error)
	GetSignalInvitationInfo(ctx context.Context, in *GetSignalInvitationInfoReq, opts ...grpc.CallOption) (*GetSignalInvitationInfoResp, error)
	GetSignalInvitationInfoStartApp(ctx context.Context, in *GetSignalInvitationInfoStartAppReq, opts ...grpc.CallOption) (*GetSignalInvitationInfoStartAppResp, error)
	FcmUpdateToken(ctx context.Context, in *FcmUpdateTokenReq, opts ...grpc.CallOption) (*FcmUpdateTokenResp, error)
	SetAppBadge(ctx context.Context, in *SetAppBadgeReq, opts ...grpc.CallOption) (*SetAppBadgeResp, error)
}

type thirdClient struct {
	cc *grpc.ClientConn
}

func NewThirdClient(cc *grpc.ClientConn) ThirdClient {
	return &thirdClient{cc}
}

func (c *thirdClient) ApplyPut(ctx context.Context, in *ApplyPutReq, opts ...grpc.CallOption) (*ApplyPutResp, error) {
	out := new(ApplyPutResp)
	err := grpc.Invoke(ctx, "/OpenIMServer.third.third/ApplyPut", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *thirdClient) GetPut(ctx context.Context, in *GetPutReq, opts ...grpc.CallOption) (*GetPutResp, error) {
	out := new(GetPutResp)
	err := grpc.Invoke(ctx, "/OpenIMServer.third.third/GetPut", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *thirdClient) ConfirmPut(ctx context.Context, in *ConfirmPutReq, opts ...grpc.CallOption) (*ConfirmPutResp, error) {
	out := new(ConfirmPutResp)
	err := grpc.Invoke(ctx, "/OpenIMServer.third.third/ConfirmPut", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *thirdClient) GetUrl(ctx context.Context, in *GetUrlReq, opts ...grpc.CallOption) (*GetUrlResp, error) {
	out := new(GetUrlResp)
	err := grpc.Invoke(ctx, "/OpenIMServer.third.third/GetUrl", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *thirdClient) GetSignalInvitationInfo(ctx context.Context, in *GetSignalInvitationInfoReq, opts ...grpc.CallOption) (*GetSignalInvitationInfoResp, error) {
	out := new(GetSignalInvitationInfoResp)
	err := grpc.Invoke(ctx, "/OpenIMServer.third.third/GetSignalInvitationInfo", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *thirdClient) GetSignalInvitationInfoStartApp(ctx context.Context, in *GetSignalInvitationInfoStartAppReq, opts ...grpc.CallOption) (*GetSignalInvitationInfoStartAppResp, error) {
	out := new(GetSignalInvitationInfoStartAppResp)
	err := grpc.Invoke(ctx, "/OpenIMServer.third.third/GetSignalInvitationInfoStartApp", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *thirdClient) FcmUpdateToken(ctx context.Context, in *FcmUpdateTokenReq, opts ...grpc.CallOption) (*FcmUpdateTokenResp, error) {
	out := new(FcmUpdateTokenResp)
	err := grpc.Invoke(ctx, "/OpenIMServer.third.third/FcmUpdateToken", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *thirdClient) SetAppBadge(ctx context.Context, in *SetAppBadgeReq, opts ...grpc.CallOption) (*SetAppBadgeResp, error) {
	out := new(SetAppBadgeResp)
	err := grpc.Invoke(ctx, "/OpenIMServer.third.third/SetAppBadge", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Third service

type ThirdServer interface {
	ApplyPut(context.Context, *ApplyPutReq) (*ApplyPutResp, error)
	GetPut(context.Context, *GetPutReq) (*GetPutResp, error)
	ConfirmPut(context.Context, *ConfirmPutReq) (*ConfirmPutResp, error)
	GetUrl(context.Context, *GetUrlReq) (*GetUrlResp, error)
	GetSignalInvitationInfo(context.Context, *GetSignalInvitationInfoReq) (*GetSignalInvitationInfoResp, error)
	GetSignalInvitationInfoStartApp(context.Context, *GetSignalInvitationInfoStartAppReq) (*GetSignalInvitationInfoStartAppResp, error)
	FcmUpdateToken(context.Context, *FcmUpdateTokenReq) (*FcmUpdateTokenResp, error)
	SetAppBadge(context.Context, *SetAppBadgeReq) (*SetAppBadgeResp, error)
}

func RegisterThirdServer(s *grpc.Server, srv ThirdServer) {
	s.RegisterService(&_Third_serviceDesc, srv)
}

func _Third_ApplyPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyPutReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).ApplyPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/OpenIMServer.third.third/ApplyPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).ApplyPut(ctx, req.(*ApplyPutReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Third_GetPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPutReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).GetPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/OpenIMServer.third.third/GetPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).GetPut(ctx, req.(*GetPutReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Third_ConfirmPut_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConfirmPutReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).ConfirmPut(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/OpenIMServer.third.third/ConfirmPut",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).ConfirmPut(ctx, req.(*ConfirmPutReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Third_GetUrl_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetUrlReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).GetUrl(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/OpenIMServer.third.third/GetUrl",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).GetUrl(ctx, req.(*GetUrlReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Third_GetSignalInvitationInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSignalInvitationInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).GetSignalInvitationInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/OpenIMServer.third.third/GetSignalInvitationInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).GetSignalInvitationInfo(ctx, req.(*GetSignalInvitationInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Third_GetSignalInvitationInfoStartApp_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSignalInvitationInfoStartAppReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).GetSignalInvitationInfoStartApp(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/OpenIMServer.third.third/GetSignalInvitationInfoStartApp",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).GetSignalInvitationInfoStartApp(ctx, req.(*GetSignalInvitationInfoStartAppReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Third_FcmUpdateToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(FcmUpdateTokenReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).FcmUpdateToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/OpenIMServer.third.third/FcmUpdateToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).FcmUpdateToken(ctx, req.(*FcmUpdateTokenReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Third_SetAppBadge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetAppBadgeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).SetAppBadge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/OpenIMServer.third.third/SetAppBadge",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).SetAppBadge(ctx, req.(*SetAppBadgeReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _Third_serviceDesc = grpc.ServiceDesc{
	ServiceName: "OpenIMServer.third.third",
	HandlerType: (*ThirdServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ApplyPut",
			Handler:    _Third_ApplyPut_Handler,
		},
		{
			MethodName: "GetPut",
			Handler:    _Third_GetPut_Handler,
		},
		{
			MethodName: "ConfirmPut",
			Handler:    _Third_ConfirmPut_Handler,
		},
		{
			MethodName: "GetUrl",
			Handler:    _Third_GetUrl_Handler,
		},
		{
			MethodName: "GetSignalInvitationInfo",
			Handler:    _Third_GetSignalInvitationInfo_Handler,
		},
		{
			MethodName: "GetSignalInvitationInfoStartApp",
			Handler:    _Third_GetSignalInvitationInfoStartApp_Handler,
		},
		{
			MethodName: "FcmUpdateToken",
			Handler:    _Third_FcmUpdateToken_Handler,
		},
		{
			MethodName: "SetAppBadge",
			Handler:    _Third_SetAppBadge_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "third/third.proto",
}

func init() { proto.RegisterFile("third/third.proto", fileDescriptor_third_85db3e967ff9b8c1) }

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