Open-IM-Server/pkg/proto/third/third.pb.go

// 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 ApplySpaceReq 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"`
	Purpose              uint32   `protobuf:"varint,4,opt,name=purpose" json:"purpose,omitempty"`
	ContentType          string   `protobuf:"bytes,5,opt,name=contentType" json:"contentType,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ApplySpaceReq proto.InternalMessageInfo

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

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

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

func (m *ApplySpaceReq) GetPurpose() uint32 {
	if m != nil {
		return m.Purpose
	}
	return 0
}

func (m *ApplySpaceReq) GetContentType() string {
	if m != nil {
		return m.ContentType
	}
	return ""
}

type ApplySpaceResp struct {
	Url                  string   `protobuf:"bytes,1,opt,name=url" json:"url,omitempty"`
	Size                 int64    `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	Put                  []string `protobuf:"bytes,3,rep,name=put" json:"put,omitempty"`
	ConfirmID            string   `protobuf:"bytes,4,opt,name=confirmID" json:"confirmID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ApplySpaceResp proto.InternalMessageInfo

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

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

func (m *ApplySpaceResp) GetPut() []string {
	if m != nil {
		return m.Put
	}
	return nil
}

func (m *ApplySpaceResp) GetConfirmID() string {
	if m != nil {
		return m.ConfirmID
	}
	return ""
}

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

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

var xxx_messageInfo_ConfirmSpaceReq proto.InternalMessageInfo

func (m *ConfirmSpaceReq) GetConfirmID() string {
	if m != nil {
		return m.ConfirmID
	}
	return ""
}

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

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

var xxx_messageInfo_ConfirmSpaceResp proto.InternalMessageInfo

func (m *ConfirmSpaceResp) GetConfirmID() string {
	if m != nil {
		return m.ConfirmID
	}
	return ""
}

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_3f9746cdadff77e4, []int{4}
}
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_3f9746cdadff77e4, []int{5}
}
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_3f9746cdadff77e4, []int{6}
}
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_3f9746cdadff77e4, []int{7}
}
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 {
	Platform             int32    `protobuf:"varint,1,opt,name=Platform" json:"Platform,omitempty"`
	FcmToken             string   `protobuf:"bytes,2,opt,name=FcmToken" json:"FcmToken,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_3f9746cdadff77e4, []int{8}
}
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) GetPlatform() int32 {
	if m != nil {
		return m.Platform
	}
	return 0
}

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

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_3f9746cdadff77e4, []int{9}
}
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 {
	FromUserID           string   `protobuf:"bytes,1,opt,name=FromUserID" json:"FromUserID,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_3f9746cdadff77e4, []int{10}
}
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) GetFromUserID() string {
	if m != nil {
		return m.FromUserID
	}
	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_3f9746cdadff77e4, []int{11}
}
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((*ApplySpaceReq)(nil), "third.ApplySpaceReq")
	proto.RegisterType((*ApplySpaceResp)(nil), "third.ApplySpaceResp")
	proto.RegisterType((*ConfirmSpaceReq)(nil), "third.ConfirmSpaceReq")
	proto.RegisterType((*ConfirmSpaceResp)(nil), "third.ConfirmSpaceResp")
	proto.RegisterType((*GetSignalInvitationInfoReq)(nil), "third.GetSignalInvitationInfoReq")
	proto.RegisterType((*GetSignalInvitationInfoResp)(nil), "third.GetSignalInvitationInfoResp")
	proto.RegisterType((*GetSignalInvitationInfoStartAppReq)(nil), "third.GetSignalInvitationInfoStartAppReq")
	proto.RegisterType((*GetSignalInvitationInfoStartAppResp)(nil), "third.GetSignalInvitationInfoStartAppResp")
	proto.RegisterType((*FcmUpdateTokenReq)(nil), "third.FcmUpdateTokenReq")
	proto.RegisterType((*FcmUpdateTokenResp)(nil), "third.FcmUpdateTokenResp")
	proto.RegisterType((*SetAppBadgeReq)(nil), "third.SetAppBadgeReq")
	proto.RegisterType((*SetAppBadgeResp)(nil), "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 {
	ApplySpace(ctx context.Context, in *ApplySpaceReq, opts ...grpc.CallOption) (*ApplySpaceResp, 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) ApplySpace(ctx context.Context, in *ApplySpaceReq, opts ...grpc.CallOption) (*ApplySpaceResp, error) {
	out := new(ApplySpaceResp)
	err := grpc.Invoke(ctx, "/third.third/ApplySpace", 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, "/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, "/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, "/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, "/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 {
	ApplySpace(context.Context, *ApplySpaceReq) (*ApplySpaceResp, 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_ApplySpace_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplySpaceReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThirdServer).ApplySpace(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/third.third/ApplySpace",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThirdServer).ApplySpace(ctx, req.(*ApplySpaceReq))
	}
	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: "/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: "/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: "/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: "/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: "third.third",
	HandlerType: (*ThirdServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ApplySpace",
			Handler:    _Third_ApplySpace_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_3f9746cdadff77e4) }

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