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

package proto

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

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

func (m *CrossCheatResetLikeCountRequset) Reset()         { *m = CrossCheatResetLikeCountRequset{} }
func (m *CrossCheatResetLikeCountRequset) String() string { return proto.CompactTextString(m) }
func (*CrossCheatResetLikeCountRequset) ProtoMessage()    {}
func (*CrossCheatResetLikeCountRequset) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{0}
}

func (m *CrossCheatResetLikeCountRequset) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatResetLikeCountRequset.Unmarshal(m, b)
}
func (m *CrossCheatResetLikeCountRequset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatResetLikeCountRequset.Marshal(b, m, deterministic)
}
func (m *CrossCheatResetLikeCountRequset) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatResetLikeCountRequset.Merge(m, src)
}
func (m *CrossCheatResetLikeCountRequset) XXX_Size() int {
	return xxx_messageInfo_CrossCheatResetLikeCountRequset.Size(m)
}
func (m *CrossCheatResetLikeCountRequset) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatResetLikeCountRequset.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatResetLikeCountRequset proto.InternalMessageInfo

func (m *CrossCheatResetLikeCountRequset) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type CrossCheatResetLikeCountResponse struct {
	Code                 int64    `protobuf:"zigzag64,1,opt,name=code,proto3" json:"code,omitempty"`
	Info                 string   `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrossCheatResetLikeCountResponse) Reset()         { *m = CrossCheatResetLikeCountResponse{} }
func (m *CrossCheatResetLikeCountResponse) String() string { return proto.CompactTextString(m) }
func (*CrossCheatResetLikeCountResponse) ProtoMessage()    {}
func (*CrossCheatResetLikeCountResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{1}
}

func (m *CrossCheatResetLikeCountResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatResetLikeCountResponse.Unmarshal(m, b)
}
func (m *CrossCheatResetLikeCountResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatResetLikeCountResponse.Marshal(b, m, deterministic)
}
func (m *CrossCheatResetLikeCountResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatResetLikeCountResponse.Merge(m, src)
}
func (m *CrossCheatResetLikeCountResponse) XXX_Size() int {
	return xxx_messageInfo_CrossCheatResetLikeCountResponse.Size(m)
}
func (m *CrossCheatResetLikeCountResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatResetLikeCountResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatResetLikeCountResponse proto.InternalMessageInfo

func (m *CrossCheatResetLikeCountResponse) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *CrossCheatResetLikeCountResponse) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

type CrossCheatAddTrophyRequest struct {
	Id                   string   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	No                   int32    `protobuf:"zigzag32,2,opt,name=no,proto3" json:"no,omitempty"`
	Level                int32    `protobuf:"zigzag32,3,opt,name=level,proto3" json:"level,omitempty"`
	GetTime              int64    `protobuf:"zigzag64,4,opt,name=get_time,json=getTime,proto3" json:"get_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrossCheatAddTrophyRequest) Reset()         { *m = CrossCheatAddTrophyRequest{} }
func (m *CrossCheatAddTrophyRequest) String() string { return proto.CompactTextString(m) }
func (*CrossCheatAddTrophyRequest) ProtoMessage()    {}
func (*CrossCheatAddTrophyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{2}
}

func (m *CrossCheatAddTrophyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatAddTrophyRequest.Unmarshal(m, b)
}
func (m *CrossCheatAddTrophyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatAddTrophyRequest.Marshal(b, m, deterministic)
}
func (m *CrossCheatAddTrophyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatAddTrophyRequest.Merge(m, src)
}
func (m *CrossCheatAddTrophyRequest) XXX_Size() int {
	return xxx_messageInfo_CrossCheatAddTrophyRequest.Size(m)
}
func (m *CrossCheatAddTrophyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatAddTrophyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatAddTrophyRequest proto.InternalMessageInfo

func (m *CrossCheatAddTrophyRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *CrossCheatAddTrophyRequest) GetNo() int32 {
	if m != nil {
		return m.No
	}
	return 0
}

func (m *CrossCheatAddTrophyRequest) GetLevel() int32 {
	if m != nil {
		return m.Level
	}
	return 0
}

func (m *CrossCheatAddTrophyRequest) GetGetTime() int64 {
	if m != nil {
		return m.GetTime
	}
	return 0
}

type CrossCheatAddTrophyResponse struct {
	Code                 int64                             `protobuf:"zigzag64,1,opt,name=code,proto3" json:"code,omitempty"`
	Info                 string                            `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	Data                 *CrossCheatAddTrophyResponse_Data `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                          `json:"-"`
	XXX_unrecognized     []byte                            `json:"-"`
	XXX_sizecache        int32                             `json:"-"`
}

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

func (m *CrossCheatAddTrophyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatAddTrophyResponse.Unmarshal(m, b)
}
func (m *CrossCheatAddTrophyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatAddTrophyResponse.Marshal(b, m, deterministic)
}
func (m *CrossCheatAddTrophyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatAddTrophyResponse.Merge(m, src)
}
func (m *CrossCheatAddTrophyResponse) XXX_Size() int {
	return xxx_messageInfo_CrossCheatAddTrophyResponse.Size(m)
}
func (m *CrossCheatAddTrophyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatAddTrophyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatAddTrophyResponse proto.InternalMessageInfo

func (m *CrossCheatAddTrophyResponse) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *CrossCheatAddTrophyResponse) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func (m *CrossCheatAddTrophyResponse) GetData() *CrossCheatAddTrophyResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type CrossCheatAddTrophyResponse_Data struct {
	HasAdd               bool     `protobuf:"varint,1,opt,name=has_add,json=hasAdd,proto3" json:"has_add,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

func (m *CrossCheatAddTrophyResponse_Data) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatAddTrophyResponse_Data.Unmarshal(m, b)
}
func (m *CrossCheatAddTrophyResponse_Data) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatAddTrophyResponse_Data.Marshal(b, m, deterministic)
}
func (m *CrossCheatAddTrophyResponse_Data) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatAddTrophyResponse_Data.Merge(m, src)
}
func (m *CrossCheatAddTrophyResponse_Data) XXX_Size() int {
	return xxx_messageInfo_CrossCheatAddTrophyResponse_Data.Size(m)
}
func (m *CrossCheatAddTrophyResponse_Data) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatAddTrophyResponse_Data.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatAddTrophyResponse_Data proto.InternalMessageInfo

func (m *CrossCheatAddTrophyResponse_Data) GetHasAdd() bool {
	if m != nil {
		return m.HasAdd
	}
	return false
}

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

func (m *CrossCheatAddAllTrophyRequest) Reset()         { *m = CrossCheatAddAllTrophyRequest{} }
func (m *CrossCheatAddAllTrophyRequest) String() string { return proto.CompactTextString(m) }
func (*CrossCheatAddAllTrophyRequest) ProtoMessage()    {}
func (*CrossCheatAddAllTrophyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{4}
}

func (m *CrossCheatAddAllTrophyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatAddAllTrophyRequest.Unmarshal(m, b)
}
func (m *CrossCheatAddAllTrophyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatAddAllTrophyRequest.Marshal(b, m, deterministic)
}
func (m *CrossCheatAddAllTrophyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatAddAllTrophyRequest.Merge(m, src)
}
func (m *CrossCheatAddAllTrophyRequest) XXX_Size() int {
	return xxx_messageInfo_CrossCheatAddAllTrophyRequest.Size(m)
}
func (m *CrossCheatAddAllTrophyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatAddAllTrophyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatAddAllTrophyRequest proto.InternalMessageInfo

func (m *CrossCheatAddAllTrophyRequest) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

type CrossCheatAddAllTrophyResponse struct {
	Code                 int64    `protobuf:"zigzag64,1,opt,name=code,proto3" json:"code,omitempty"`
	Info                 string   `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrossCheatAddAllTrophyResponse) Reset()         { *m = CrossCheatAddAllTrophyResponse{} }
func (m *CrossCheatAddAllTrophyResponse) String() string { return proto.CompactTextString(m) }
func (*CrossCheatAddAllTrophyResponse) ProtoMessage()    {}
func (*CrossCheatAddAllTrophyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{5}
}

func (m *CrossCheatAddAllTrophyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatAddAllTrophyResponse.Unmarshal(m, b)
}
func (m *CrossCheatAddAllTrophyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatAddAllTrophyResponse.Marshal(b, m, deterministic)
}
func (m *CrossCheatAddAllTrophyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatAddAllTrophyResponse.Merge(m, src)
}
func (m *CrossCheatAddAllTrophyResponse) XXX_Size() int {
	return xxx_messageInfo_CrossCheatAddAllTrophyResponse.Size(m)
}
func (m *CrossCheatAddAllTrophyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatAddAllTrophyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatAddAllTrophyResponse proto.InternalMessageInfo

func (m *CrossCheatAddAllTrophyResponse) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *CrossCheatAddAllTrophyResponse) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

type CrossCheatCleanTrophyRequest struct {
	ServerId             int32    `protobuf:"varint,1,opt,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrossCheatCleanTrophyRequest) Reset()         { *m = CrossCheatCleanTrophyRequest{} }
func (m *CrossCheatCleanTrophyRequest) String() string { return proto.CompactTextString(m) }
func (*CrossCheatCleanTrophyRequest) ProtoMessage()    {}
func (*CrossCheatCleanTrophyRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{6}
}

func (m *CrossCheatCleanTrophyRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatCleanTrophyRequest.Unmarshal(m, b)
}
func (m *CrossCheatCleanTrophyRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatCleanTrophyRequest.Marshal(b, m, deterministic)
}
func (m *CrossCheatCleanTrophyRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatCleanTrophyRequest.Merge(m, src)
}
func (m *CrossCheatCleanTrophyRequest) XXX_Size() int {
	return xxx_messageInfo_CrossCheatCleanTrophyRequest.Size(m)
}
func (m *CrossCheatCleanTrophyRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatCleanTrophyRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatCleanTrophyRequest proto.InternalMessageInfo

func (m *CrossCheatCleanTrophyRequest) GetServerId() int32 {
	if m != nil {
		return m.ServerId
	}
	return 0
}

type CrossCheatCleanTrophyResponse struct {
	Code                 int64    `protobuf:"zigzag64,1,opt,name=code,proto3" json:"code,omitempty"`
	Info                 string   `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrossCheatCleanTrophyResponse) Reset()         { *m = CrossCheatCleanTrophyResponse{} }
func (m *CrossCheatCleanTrophyResponse) String() string { return proto.CompactTextString(m) }
func (*CrossCheatCleanTrophyResponse) ProtoMessage()    {}
func (*CrossCheatCleanTrophyResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{7}
}

func (m *CrossCheatCleanTrophyResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatCleanTrophyResponse.Unmarshal(m, b)
}
func (m *CrossCheatCleanTrophyResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatCleanTrophyResponse.Marshal(b, m, deterministic)
}
func (m *CrossCheatCleanTrophyResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatCleanTrophyResponse.Merge(m, src)
}
func (m *CrossCheatCleanTrophyResponse) XXX_Size() int {
	return xxx_messageInfo_CrossCheatCleanTrophyResponse.Size(m)
}
func (m *CrossCheatCleanTrophyResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatCleanTrophyResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatCleanTrophyResponse proto.InternalMessageInfo

func (m *CrossCheatCleanTrophyResponse) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *CrossCheatCleanTrophyResponse) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

type CrossCheatReloadRuleRequest struct {
	Version              int64    `protobuf:"zigzag64,1,opt,name=version,proto3" json:"version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrossCheatReloadRuleRequest) Reset()         { *m = CrossCheatReloadRuleRequest{} }
func (m *CrossCheatReloadRuleRequest) String() string { return proto.CompactTextString(m) }
func (*CrossCheatReloadRuleRequest) ProtoMessage()    {}
func (*CrossCheatReloadRuleRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{8}
}

func (m *CrossCheatReloadRuleRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatReloadRuleRequest.Unmarshal(m, b)
}
func (m *CrossCheatReloadRuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatReloadRuleRequest.Marshal(b, m, deterministic)
}
func (m *CrossCheatReloadRuleRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatReloadRuleRequest.Merge(m, src)
}
func (m *CrossCheatReloadRuleRequest) XXX_Size() int {
	return xxx_messageInfo_CrossCheatReloadRuleRequest.Size(m)
}
func (m *CrossCheatReloadRuleRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatReloadRuleRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatReloadRuleRequest proto.InternalMessageInfo

func (m *CrossCheatReloadRuleRequest) GetVersion() int64 {
	if m != nil {
		return m.Version
	}
	return 0
}

type CrossCheatReloadRuleResponse struct {
	Code                 int64    `protobuf:"zigzag64,1,opt,name=code,proto3" json:"code,omitempty"`
	Info                 string   `protobuf:"bytes,2,opt,name=info,proto3" json:"info,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CrossCheatReloadRuleResponse) Reset()         { *m = CrossCheatReloadRuleResponse{} }
func (m *CrossCheatReloadRuleResponse) String() string { return proto.CompactTextString(m) }
func (*CrossCheatReloadRuleResponse) ProtoMessage()    {}
func (*CrossCheatReloadRuleResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_14e2b11dfc82d7e3, []int{9}
}

func (m *CrossCheatReloadRuleResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CrossCheatReloadRuleResponse.Unmarshal(m, b)
}
func (m *CrossCheatReloadRuleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CrossCheatReloadRuleResponse.Marshal(b, m, deterministic)
}
func (m *CrossCheatReloadRuleResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CrossCheatReloadRuleResponse.Merge(m, src)
}
func (m *CrossCheatReloadRuleResponse) XXX_Size() int {
	return xxx_messageInfo_CrossCheatReloadRuleResponse.Size(m)
}
func (m *CrossCheatReloadRuleResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CrossCheatReloadRuleResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CrossCheatReloadRuleResponse proto.InternalMessageInfo

func (m *CrossCheatReloadRuleResponse) GetCode() int64 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *CrossCheatReloadRuleResponse) GetInfo() string {
	if m != nil {
		return m.Info
	}
	return ""
}

func init() {
	proto.RegisterType((*CrossCheatResetLikeCountRequset)(nil), "proto.CrossCheatResetLikeCountRequset")
	proto.RegisterType((*CrossCheatResetLikeCountResponse)(nil), "proto.CrossCheatResetLikeCountResponse")
	proto.RegisterType((*CrossCheatAddTrophyRequest)(nil), "proto.CrossCheatAddTrophyRequest")
	proto.RegisterType((*CrossCheatAddTrophyResponse)(nil), "proto.CrossCheatAddTrophyResponse")
	proto.RegisterType((*CrossCheatAddTrophyResponse_Data)(nil), "proto.CrossCheatAddTrophyResponse.Data")
	proto.RegisterType((*CrossCheatAddAllTrophyRequest)(nil), "proto.CrossCheatAddAllTrophyRequest")
	proto.RegisterType((*CrossCheatAddAllTrophyResponse)(nil), "proto.CrossCheatAddAllTrophyResponse")
	proto.RegisterType((*CrossCheatCleanTrophyRequest)(nil), "proto.CrossCheatCleanTrophyRequest")
	proto.RegisterType((*CrossCheatCleanTrophyResponse)(nil), "proto.CrossCheatCleanTrophyResponse")
	proto.RegisterType((*CrossCheatReloadRuleRequest)(nil), "proto.CrossCheatReloadRuleRequest")
	proto.RegisterType((*CrossCheatReloadRuleResponse)(nil), "proto.CrossCheatReloadRuleResponse")
}

func init() { proto.RegisterFile("service/cross_role_cheat.proto", fileDescriptor_14e2b11dfc82d7e3) }

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

// 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

// RoleCheatServiceClient is the client API for RoleCheatService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RoleCheatServiceClient interface {
	CheatResetLikeCount(ctx context.Context, in *CrossCheatResetLikeCountRequset, opts ...grpc.CallOption) (*CrossCheatResetLikeCountResponse, error)
	CheatAddTrophy(ctx context.Context, in *CrossCheatAddTrophyRequest, opts ...grpc.CallOption) (*CrossCheatAddTrophyResponse, error)
	CheatAddAllTrophy(ctx context.Context, in *CrossCheatAddAllTrophyRequest, opts ...grpc.CallOption) (*CrossCheatAddAllTrophyResponse, error)
	CheatCleanTrophy(ctx context.Context, in *CrossCheatCleanTrophyRequest, opts ...grpc.CallOption) (*CrossCheatCleanTrophyResponse, error)
	CheatReloadRule(ctx context.Context, in *CrossCheatReloadRuleRequest, opts ...grpc.CallOption) (*CrossCheatReloadRuleResponse, error)
}

type roleCheatServiceClient struct {
	cc *grpc.ClientConn
}

func NewRoleCheatServiceClient(cc *grpc.ClientConn) RoleCheatServiceClient {
	return &roleCheatServiceClient{cc}
}

func (c *roleCheatServiceClient) CheatResetLikeCount(ctx context.Context, in *CrossCheatResetLikeCountRequset, opts ...grpc.CallOption) (*CrossCheatResetLikeCountResponse, error) {
	out := new(CrossCheatResetLikeCountResponse)
	err := c.cc.Invoke(ctx, "/proto.RoleCheatService/CheatResetLikeCount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *roleCheatServiceClient) CheatAddTrophy(ctx context.Context, in *CrossCheatAddTrophyRequest, opts ...grpc.CallOption) (*CrossCheatAddTrophyResponse, error) {
	out := new(CrossCheatAddTrophyResponse)
	err := c.cc.Invoke(ctx, "/proto.RoleCheatService/CheatAddTrophy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *roleCheatServiceClient) CheatAddAllTrophy(ctx context.Context, in *CrossCheatAddAllTrophyRequest, opts ...grpc.CallOption) (*CrossCheatAddAllTrophyResponse, error) {
	out := new(CrossCheatAddAllTrophyResponse)
	err := c.cc.Invoke(ctx, "/proto.RoleCheatService/CheatAddAllTrophy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *roleCheatServiceClient) CheatCleanTrophy(ctx context.Context, in *CrossCheatCleanTrophyRequest, opts ...grpc.CallOption) (*CrossCheatCleanTrophyResponse, error) {
	out := new(CrossCheatCleanTrophyResponse)
	err := c.cc.Invoke(ctx, "/proto.RoleCheatService/CheatCleanTrophy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *roleCheatServiceClient) CheatReloadRule(ctx context.Context, in *CrossCheatReloadRuleRequest, opts ...grpc.CallOption) (*CrossCheatReloadRuleResponse, error) {
	out := new(CrossCheatReloadRuleResponse)
	err := c.cc.Invoke(ctx, "/proto.RoleCheatService/CheatReloadRule", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RoleCheatServiceServer is the server API for RoleCheatService service.
type RoleCheatServiceServer interface {
	CheatResetLikeCount(context.Context, *CrossCheatResetLikeCountRequset) (*CrossCheatResetLikeCountResponse, error)
	CheatAddTrophy(context.Context, *CrossCheatAddTrophyRequest) (*CrossCheatAddTrophyResponse, error)
	CheatAddAllTrophy(context.Context, *CrossCheatAddAllTrophyRequest) (*CrossCheatAddAllTrophyResponse, error)
	CheatCleanTrophy(context.Context, *CrossCheatCleanTrophyRequest) (*CrossCheatCleanTrophyResponse, error)
	CheatReloadRule(context.Context, *CrossCheatReloadRuleRequest) (*CrossCheatReloadRuleResponse, error)
}

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

func (*UnimplementedRoleCheatServiceServer) CheatResetLikeCount(ctx context.Context, req *CrossCheatResetLikeCountRequset) (*CrossCheatResetLikeCountResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheatResetLikeCount not implemented")
}
func (*UnimplementedRoleCheatServiceServer) CheatAddTrophy(ctx context.Context, req *CrossCheatAddTrophyRequest) (*CrossCheatAddTrophyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheatAddTrophy not implemented")
}
func (*UnimplementedRoleCheatServiceServer) CheatAddAllTrophy(ctx context.Context, req *CrossCheatAddAllTrophyRequest) (*CrossCheatAddAllTrophyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheatAddAllTrophy not implemented")
}
func (*UnimplementedRoleCheatServiceServer) CheatCleanTrophy(ctx context.Context, req *CrossCheatCleanTrophyRequest) (*CrossCheatCleanTrophyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheatCleanTrophy not implemented")
}
func (*UnimplementedRoleCheatServiceServer) CheatReloadRule(ctx context.Context, req *CrossCheatReloadRuleRequest) (*CrossCheatReloadRuleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheatReloadRule not implemented")
}

func RegisterRoleCheatServiceServer(s *grpc.Server, srv RoleCheatServiceServer) {
	s.RegisterService(&_RoleCheatService_serviceDesc, srv)
}

func _RoleCheatService_CheatResetLikeCount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrossCheatResetLikeCountRequset)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoleCheatServiceServer).CheatResetLikeCount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.RoleCheatService/CheatResetLikeCount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoleCheatServiceServer).CheatResetLikeCount(ctx, req.(*CrossCheatResetLikeCountRequset))
	}
	return interceptor(ctx, in, info, handler)
}

func _RoleCheatService_CheatAddTrophy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrossCheatAddTrophyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoleCheatServiceServer).CheatAddTrophy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.RoleCheatService/CheatAddTrophy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoleCheatServiceServer).CheatAddTrophy(ctx, req.(*CrossCheatAddTrophyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RoleCheatService_CheatAddAllTrophy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrossCheatAddAllTrophyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoleCheatServiceServer).CheatAddAllTrophy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.RoleCheatService/CheatAddAllTrophy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoleCheatServiceServer).CheatAddAllTrophy(ctx, req.(*CrossCheatAddAllTrophyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RoleCheatService_CheatCleanTrophy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrossCheatCleanTrophyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoleCheatServiceServer).CheatCleanTrophy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.RoleCheatService/CheatCleanTrophy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoleCheatServiceServer).CheatCleanTrophy(ctx, req.(*CrossCheatCleanTrophyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _RoleCheatService_CheatReloadRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrossCheatReloadRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RoleCheatServiceServer).CheatReloadRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.RoleCheatService/CheatReloadRule",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RoleCheatServiceServer).CheatReloadRule(ctx, req.(*CrossCheatReloadRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _RoleCheatService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.RoleCheatService",
	HandlerType: (*RoleCheatServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CheatResetLikeCount",
			Handler:    _RoleCheatService_CheatResetLikeCount_Handler,
		},
		{
			MethodName: "CheatAddTrophy",
			Handler:    _RoleCheatService_CheatAddTrophy_Handler,
		},
		{
			MethodName: "CheatAddAllTrophy",
			Handler:    _RoleCheatService_CheatAddAllTrophy_Handler,
		},
		{
			MethodName: "CheatCleanTrophy",
			Handler:    _RoleCheatService_CheatCleanTrophy_Handler,
		},
		{
			MethodName: "CheatReloadRule",
			Handler:    _RoleCheatService_CheatReloadRule_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "service/cross_role_cheat.proto",
}
