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

package proto

import (
	fmt "fmt"
	math "math"
	context "context"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	model "vikingar/proto/gen-go/model"
)

// 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 CrossPayRebateRuleRequest struct {
	ActivityId           string   `protobuf:"bytes,1,opt,name=activity_id,json=activityId,proto3" json:"activity_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CrossPayRebateRuleRequest proto.InternalMessageInfo

func (m *CrossPayRebateRuleRequest) GetActivityId() string {
	if m != nil {
		return m.ActivityId
	}
	return ""
}

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

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

var xxx_messageInfo_CrossPayRebateRuleResponse proto.InternalMessageInfo

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

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

func (m *CrossPayRebateRuleResponse) GetData() *CrossPayRebateRuleResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type CrossPayRebateRuleResponse_Data struct {
	EveryDayPay          []*CrossPayRebateRuleResponse_Data_VipExpGrade           `protobuf:"bytes,1,rep,name=every_day_pay,json=everyDayPay,proto3" json:"every_day_pay,omitempty"`
	CumulativePay        []*CrossPayRebateRuleResponse_Data_VipExpGrade           `protobuf:"bytes,2,rep,name=cumulative_pay,json=cumulativePay,proto3" json:"cumulative_pay,omitempty"`
	CumulativeDayPay     []*CrossPayRebateRuleResponse_Data_CumulativeDayPayGrade `protobuf:"bytes,3,rep,name=cumulative_day_pay,json=cumulativeDayPay,proto3" json:"cumulative_day_pay,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                                 `json:"-"`
	XXX_unrecognized     []byte                                                   `json:"-"`
	XXX_sizecache        int32                                                    `json:"-"`
}

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

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

var xxx_messageInfo_CrossPayRebateRuleResponse_Data proto.InternalMessageInfo

func (m *CrossPayRebateRuleResponse_Data) GetEveryDayPay() []*CrossPayRebateRuleResponse_Data_VipExpGrade {
	if m != nil {
		return m.EveryDayPay
	}
	return nil
}

func (m *CrossPayRebateRuleResponse_Data) GetCumulativePay() []*CrossPayRebateRuleResponse_Data_VipExpGrade {
	if m != nil {
		return m.CumulativePay
	}
	return nil
}

func (m *CrossPayRebateRuleResponse_Data) GetCumulativeDayPay() []*CrossPayRebateRuleResponse_Data_CumulativeDayPayGrade {
	if m != nil {
		return m.CumulativeDayPay
	}
	return nil
}

type CrossPayRebateRuleResponse_Data_VipExpGrade struct {
	No                   int32                    `protobuf:"zigzag32,1,opt,name=no,proto3" json:"no,omitempty"`
	HideStage            int32                    `protobuf:"zigzag32,2,opt,name=hide_stage,json=hideStage,proto3" json:"hide_stage,omitempty"`
	VipExp               int64                    `protobuf:"zigzag64,3,opt,name=vip_exp,json=vipExp,proto3" json:"vip_exp,omitempty"`
	Worth                int32                    `protobuf:"zigzag32,4,opt,name=worth,proto3" json:"worth,omitempty"`
	Award                []*model.GameObjectCount `protobuf:"bytes,5,rep,name=award,proto3" json:"award,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_CrossPayRebateRuleResponse_Data_VipExpGrade proto.InternalMessageInfo

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

func (m *CrossPayRebateRuleResponse_Data_VipExpGrade) GetHideStage() int32 {
	if m != nil {
		return m.HideStage
	}
	return 0
}

func (m *CrossPayRebateRuleResponse_Data_VipExpGrade) GetVipExp() int64 {
	if m != nil {
		return m.VipExp
	}
	return 0
}

func (m *CrossPayRebateRuleResponse_Data_VipExpGrade) GetWorth() int32 {
	if m != nil {
		return m.Worth
	}
	return 0
}

func (m *CrossPayRebateRuleResponse_Data_VipExpGrade) GetAward() []*model.GameObjectCount {
	if m != nil {
		return m.Award
	}
	return nil
}

type CrossPayRebateRuleResponse_Data_CumulativeDayPayGrade struct {
	Day                  int32                    `protobuf:"zigzag32,1,opt,name=day,proto3" json:"day,omitempty"`
	Worth                int32                    `protobuf:"zigzag32,2,opt,name=worth,proto3" json:"worth,omitempty"`
	Award                []*model.GameObjectCount `protobuf:"bytes,3,rep,name=award,proto3" json:"award,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_CrossPayRebateRuleResponse_Data_CumulativeDayPayGrade proto.InternalMessageInfo

func (m *CrossPayRebateRuleResponse_Data_CumulativeDayPayGrade) GetDay() int32 {
	if m != nil {
		return m.Day
	}
	return 0
}

func (m *CrossPayRebateRuleResponse_Data_CumulativeDayPayGrade) GetWorth() int32 {
	if m != nil {
		return m.Worth
	}
	return 0
}

func (m *CrossPayRebateRuleResponse_Data_CumulativeDayPayGrade) GetAward() []*model.GameObjectCount {
	if m != nil {
		return m.Award
	}
	return nil
}

type CrossPayRebateCheatAddRuleRequest struct {
	StartTime            int64    `protobuf:"zigzag64,1,opt,name=start_time,json=startTime,proto3" json:"start_time,omitempty"`
	AwardTime            int64    `protobuf:"zigzag64,2,opt,name=award_time,json=awardTime,proto3" json:"award_time,omitempty"`
	EndTime              int64    `protobuf:"zigzag64,3,opt,name=end_time,json=endTime,proto3" json:"end_time,omitempty"`
	ServerId             []int32  `protobuf:"varint,4,rep,packed,name=server_id,json=serverId,proto3" json:"server_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_CrossPayRebateCheatAddRuleRequest proto.InternalMessageInfo

func (m *CrossPayRebateCheatAddRuleRequest) GetStartTime() int64 {
	if m != nil {
		return m.StartTime
	}
	return 0
}

func (m *CrossPayRebateCheatAddRuleRequest) GetAwardTime() int64 {
	if m != nil {
		return m.AwardTime
	}
	return 0
}

func (m *CrossPayRebateCheatAddRuleRequest) GetEndTime() int64 {
	if m != nil {
		return m.EndTime
	}
	return 0
}

func (m *CrossPayRebateCheatAddRuleRequest) GetServerId() []int32 {
	if m != nil {
		return m.ServerId
	}
	return nil
}

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

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

var xxx_messageInfo_CrossPayRebateCheatAddRuleResponse proto.InternalMessageInfo

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

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

func init() {
	proto.RegisterType((*CrossPayRebateRuleRequest)(nil), "proto.CrossPayRebateRuleRequest")
	proto.RegisterType((*CrossPayRebateRuleResponse)(nil), "proto.CrossPayRebateRuleResponse")
	proto.RegisterType((*CrossPayRebateRuleResponse_Data)(nil), "proto.CrossPayRebateRuleResponse.Data")
	proto.RegisterType((*CrossPayRebateRuleResponse_Data_VipExpGrade)(nil), "proto.CrossPayRebateRuleResponse.Data.VipExpGrade")
	proto.RegisterType((*CrossPayRebateRuleResponse_Data_CumulativeDayPayGrade)(nil), "proto.CrossPayRebateRuleResponse.Data.CumulativeDayPayGrade")
	proto.RegisterType((*CrossPayRebateCheatAddRuleRequest)(nil), "proto.CrossPayRebateCheatAddRuleRequest")
	proto.RegisterType((*CrossPayRebateCheatAddRuleResponse)(nil), "proto.CrossPayRebateCheatAddRuleResponse")
}

func init() {
	proto.RegisterFile("service/cross_pay_rebate_game.proto", fileDescriptor_1771007296d0b4f0)
}

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

// PayRebateServiceClient is the client API for PayRebateService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type PayRebateServiceClient interface {
	GetPayRebateRule(ctx context.Context, in *CrossPayRebateRuleRequest, opts ...grpc.CallOption) (*CrossPayRebateRuleResponse, error)
	CheatAddPayRebateRule(ctx context.Context, in *CrossPayRebateCheatAddRuleRequest, opts ...grpc.CallOption) (*CrossPayRebateCheatAddRuleResponse, error)
}

type payRebateServiceClient struct {
	cc *grpc.ClientConn
}

func NewPayRebateServiceClient(cc *grpc.ClientConn) PayRebateServiceClient {
	return &payRebateServiceClient{cc}
}

func (c *payRebateServiceClient) GetPayRebateRule(ctx context.Context, in *CrossPayRebateRuleRequest, opts ...grpc.CallOption) (*CrossPayRebateRuleResponse, error) {
	out := new(CrossPayRebateRuleResponse)
	err := c.cc.Invoke(ctx, "/proto.PayRebateService/GetPayRebateRule", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *payRebateServiceClient) CheatAddPayRebateRule(ctx context.Context, in *CrossPayRebateCheatAddRuleRequest, opts ...grpc.CallOption) (*CrossPayRebateCheatAddRuleResponse, error) {
	out := new(CrossPayRebateCheatAddRuleResponse)
	err := c.cc.Invoke(ctx, "/proto.PayRebateService/CheatAddPayRebateRule", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// PayRebateServiceServer is the server API for PayRebateService service.
type PayRebateServiceServer interface {
	GetPayRebateRule(context.Context, *CrossPayRebateRuleRequest) (*CrossPayRebateRuleResponse, error)
	CheatAddPayRebateRule(context.Context, *CrossPayRebateCheatAddRuleRequest) (*CrossPayRebateCheatAddRuleResponse, error)
}

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

func (*UnimplementedPayRebateServiceServer) GetPayRebateRule(ctx context.Context, req *CrossPayRebateRuleRequest) (*CrossPayRebateRuleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPayRebateRule not implemented")
}
func (*UnimplementedPayRebateServiceServer) CheatAddPayRebateRule(ctx context.Context, req *CrossPayRebateCheatAddRuleRequest) (*CrossPayRebateCheatAddRuleResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CheatAddPayRebateRule not implemented")
}

func RegisterPayRebateServiceServer(s *grpc.Server, srv PayRebateServiceServer) {
	s.RegisterService(&_PayRebateService_serviceDesc, srv)
}

func _PayRebateService_GetPayRebateRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrossPayRebateRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PayRebateServiceServer).GetPayRebateRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.PayRebateService/GetPayRebateRule",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PayRebateServiceServer).GetPayRebateRule(ctx, req.(*CrossPayRebateRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _PayRebateService_CheatAddPayRebateRule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CrossPayRebateCheatAddRuleRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PayRebateServiceServer).CheatAddPayRebateRule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.PayRebateService/CheatAddPayRebateRule",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PayRebateServiceServer).CheatAddPayRebateRule(ctx, req.(*CrossPayRebateCheatAddRuleRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _PayRebateService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.PayRebateService",
	HandlerType: (*PayRebateServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetPayRebateRule",
			Handler:    _PayRebateService_GetPayRebateRule_Handler,
		},
		{
			MethodName: "CheatAddPayRebateRule",
			Handler:    _PayRebateService_CheatAddPayRebateRule_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "service/cross_pay_rebate_game.proto",
}
