// Code generated by protoc-gen-go. DO NOT EDIT.
// source: service/cross_sailing_cheat.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 SailingCreateDefaultActivityRPCRequest struct {
	Base                 *SailingCheatRequestBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Time                 *model.ActivityTime      `protobuf:"bytes,2,opt,name=time,proto3" json:"time,omitempty"`
	Server               []int32                  `protobuf:"varint,3,rep,packed,name=server,proto3" json:"server,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_SailingCreateDefaultActivityRPCRequest proto.InternalMessageInfo

func (m *SailingCreateDefaultActivityRPCRequest) GetBase() *SailingCheatRequestBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *SailingCreateDefaultActivityRPCRequest) GetTime() *model.ActivityTime {
	if m != nil {
		return m.Time
	}
	return nil
}

func (m *SailingCreateDefaultActivityRPCRequest) GetServer() []int32 {
	if m != nil {
		return m.Server
	}
	return nil
}

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

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

var xxx_messageInfo_SailingCreateDefaultActivityRPCResponse proto.InternalMessageInfo

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

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

// 解锁至该海域
type SailingUnlockToAreaRPCRequest struct {
	Base                 *SailingCheatRequestBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Area                 int32                    `protobuf:"varint,2,opt,name=area,proto3" json:"area,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_SailingUnlockToAreaRPCRequest proto.InternalMessageInfo

func (m *SailingUnlockToAreaRPCRequest) GetBase() *SailingCheatRequestBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *SailingUnlockToAreaRPCRequest) GetArea() int32 {
	if m != nil {
		return m.Area
	}
	return 0
}

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

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

var xxx_messageInfo_SailingUnlockToAreaRPCResponse proto.InternalMessageInfo

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

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

func (m *SailingUnlockToAreaRPCResponse) GetData() *SailingUnlockToAreaRPCResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type SailingUnlockToAreaRPCResponse_Data struct {
	Area                 *model.SailingArea `protobuf:"bytes,1,opt,name=area,proto3" json:"area,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_SailingUnlockToAreaRPCResponse_Data proto.InternalMessageInfo

func (m *SailingUnlockToAreaRPCResponse_Data) GetArea() *model.SailingArea {
	if m != nil {
		return m.Area
	}
	return nil
}

// 设定当前敌人剩余百分比
type SailingModifyHPRPCRequest struct {
	Base                 *SailingCheatRequestBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Ratio                int32                    `protobuf:"varint,2,opt,name=ratio,proto3" json:"ratio,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_SailingModifyHPRPCRequest proto.InternalMessageInfo

func (m *SailingModifyHPRPCRequest) GetBase() *SailingCheatRequestBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *SailingModifyHPRPCRequest) GetRatio() int32 {
	if m != nil {
		return m.Ratio
	}
	return 0
}

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

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

var xxx_messageInfo_SailingModifyHPRPCResponse proto.InternalMessageInfo

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

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

func (m *SailingModifyHPRPCResponse) GetData() *SailingModifyHPRPCResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type SailingModifyHPRPCResponse_Data struct {
	Role                 *model.SailingRole `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_SailingModifyHPRPCResponse_Data proto.InternalMessageInfo

func (m *SailingModifyHPRPCResponse_Data) GetRole() *model.SailingRole {
	if m != nil {
		return m.Role
	}
	return nil
}

// 修改已解锁最高级海域星星数量
type SailingModifyStarRPCRequest struct {
	Base                 *SailingCheatRequestBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Star                 int32                    `protobuf:"varint,2,opt,name=star,proto3" json:"star,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_SailingModifyStarRPCRequest proto.InternalMessageInfo

func (m *SailingModifyStarRPCRequest) GetBase() *SailingCheatRequestBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *SailingModifyStarRPCRequest) GetStar() int32 {
	if m != nil {
		return m.Star
	}
	return 0
}

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

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

var xxx_messageInfo_SailingModifyStarRPCResponse proto.InternalMessageInfo

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

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

func (m *SailingModifyStarRPCResponse) GetData() *SailingModifyStarRPCResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type SailingModifyStarRPCResponse_Data struct {
	Area                 *model.SailingArea `protobuf:"bytes,1,opt,name=area,proto3" json:"area,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_SailingModifyStarRPCResponse_Data proto.InternalMessageInfo

func (m *SailingModifyStarRPCResponse_Data) GetArea() *model.SailingArea {
	if m != nil {
		return m.Area
	}
	return nil
}

// 重置切换海域CD
type SailingResetSwitchCDRPCRequest struct {
	Base                 *SailingCheatRequestBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_SailingResetSwitchCDRPCRequest proto.InternalMessageInfo

func (m *SailingResetSwitchCDRPCRequest) GetBase() *SailingCheatRequestBase {
	if m != nil {
		return m.Base
	}
	return nil
}

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

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

var xxx_messageInfo_SailingResetSwitchCDRPCResponse proto.InternalMessageInfo

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

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

func (m *SailingResetSwitchCDRPCResponse) GetData() *SailingResetSwitchCDRPCResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type SailingResetSwitchCDRPCResponse_Data struct {
	Area                 *model.SailingArea `protobuf:"bytes,1,opt,name=area,proto3" json:"area,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

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

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

var xxx_messageInfo_SailingResetSwitchCDRPCResponse_Data proto.InternalMessageInfo

func (m *SailingResetSwitchCDRPCResponse_Data) GetArea() *model.SailingArea {
	if m != nil {
		return m.Area
	}
	return nil
}

// 生成事件
type SailingGenerateEventRPCRequest struct {
	Base                 *SailingCheatRequestBase `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Typ                  int32                    `protobuf:"varint,2,opt,name=typ,proto3" json:"typ,omitempty"`
	Arg                  int64                    `protobuf:"varint,3,opt,name=arg,proto3" json:"arg,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

func (m *SailingGenerateEventRPCRequest) Reset()         { *m = SailingGenerateEventRPCRequest{} }
func (m *SailingGenerateEventRPCRequest) String() string { return proto.CompactTextString(m) }
func (*SailingGenerateEventRPCRequest) ProtoMessage()    {}
func (*SailingGenerateEventRPCRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_fd8cd560c6d74746, []int{10}
}

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

var xxx_messageInfo_SailingGenerateEventRPCRequest proto.InternalMessageInfo

func (m *SailingGenerateEventRPCRequest) GetBase() *SailingCheatRequestBase {
	if m != nil {
		return m.Base
	}
	return nil
}

func (m *SailingGenerateEventRPCRequest) GetTyp() int32 {
	if m != nil {
		return m.Typ
	}
	return 0
}

func (m *SailingGenerateEventRPCRequest) GetArg() int64 {
	if m != nil {
		return m.Arg
	}
	return 0
}

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

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

var xxx_messageInfo_SailingGenerateEventRPCResponse proto.InternalMessageInfo

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

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

func (m *SailingGenerateEventRPCResponse) GetData() *SailingGenerateEventRPCResponse_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

type SailingGenerateEventRPCResponse_Data struct {
	EventType            int32                    `protobuf:"varint,1,opt,name=event_type,json=eventType,proto3" json:"event_type,omitempty"`
	RewardEventType      int32                    `protobuf:"varint,2,opt,name=reward_event_type,json=rewardEventType,proto3" json:"reward_event_type,omitempty"`
	Reward               []*model.GameObjectCount `protobuf:"bytes,3,rep,name=reward,proto3" json:"reward,omitempty"`
	Role                 *model.SailingRole      `protobuf:"bytes,4,opt,name=role,proto3" json:"role,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
	XXX_unrecognized     []byte                   `json:"-"`
	XXX_sizecache        int32                    `json:"-"`
}

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

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

var xxx_messageInfo_SailingGenerateEventRPCResponse_Data proto.InternalMessageInfo

func (m *SailingGenerateEventRPCResponse_Data) GetEventType() int32 {
	if m != nil {
		return m.EventType
	}
	return 0
}

func (m *SailingGenerateEventRPCResponse_Data) GetRewardEventType() int32 {
	if m != nil {
		return m.RewardEventType
	}
	return 0
}

func (m *SailingGenerateEventRPCResponse_Data) GetReward() []*model.GameObjectCount {
	if m != nil {
		return m.Reward
	}
	return nil
}

func (m *SailingGenerateEventRPCResponse_Data) GetRole() *model.SailingRole {
	if m != nil {
		return m.Role
	}
	return nil
}

// 荒海探险请求基础数据
type SailingCheatRequestBase struct {
	RoleId               string   `protobuf:"bytes,1,opt,name=role_id,json=roleId,proto3" json:"role_id,omitempty"`
	ActId                string   `protobuf:"bytes,2,opt,name=act_id,json=actId,proto3" json:"act_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SailingCheatRequestBase) Reset()         { *m = SailingCheatRequestBase{} }
func (m *SailingCheatRequestBase) String() string { return proto.CompactTextString(m) }
func (*SailingCheatRequestBase) ProtoMessage()    {}
func (*SailingCheatRequestBase) Descriptor() ([]byte, []int) {
	return fileDescriptor_fd8cd560c6d74746, []int{12}
}

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

var xxx_messageInfo_SailingCheatRequestBase proto.InternalMessageInfo

func (m *SailingCheatRequestBase) GetRoleId() string {
	if m != nil {
		return m.RoleId
	}
	return ""
}

func (m *SailingCheatRequestBase) GetActId() string {
	if m != nil {
		return m.ActId
	}
	return ""
}

func init() {
	proto.RegisterType((*SailingCreateDefaultActivityRPCRequest)(nil), "proto.SailingCreateDefaultActivityRPCRequest")
	proto.RegisterType((*SailingCreateDefaultActivityRPCResponse)(nil), "proto.SailingCreateDefaultActivityRPCResponse")
	proto.RegisterType((*SailingUnlockToAreaRPCRequest)(nil), "proto.SailingUnlockToAreaRPCRequest")
	proto.RegisterType((*SailingUnlockToAreaRPCResponse)(nil), "proto.SailingUnlockToAreaRPCResponse")
	proto.RegisterType((*SailingUnlockToAreaRPCResponse_Data)(nil), "proto.SailingUnlockToAreaRPCResponse.Data")
	proto.RegisterType((*SailingModifyHPRPCRequest)(nil), "proto.SailingModifyHPRPCRequest")
	proto.RegisterType((*SailingModifyHPRPCResponse)(nil), "proto.SailingModifyHPRPCResponse")
	proto.RegisterType((*SailingModifyHPRPCResponse_Data)(nil), "proto.SailingModifyHPRPCResponse.Data")
	proto.RegisterType((*SailingModifyStarRPCRequest)(nil), "proto.SailingModifyStarRPCRequest")
	proto.RegisterType((*SailingModifyStarRPCResponse)(nil), "proto.SailingModifyStarRPCResponse")
	proto.RegisterType((*SailingModifyStarRPCResponse_Data)(nil), "proto.SailingModifyStarRPCResponse.Data")
	proto.RegisterType((*SailingResetSwitchCDRPCRequest)(nil), "proto.SailingResetSwitchCDRPCRequest")
	proto.RegisterType((*SailingResetSwitchCDRPCResponse)(nil), "proto.SailingResetSwitchCDRPCResponse")
	proto.RegisterType((*SailingResetSwitchCDRPCResponse_Data)(nil), "proto.SailingResetSwitchCDRPCResponse.Data")
	proto.RegisterType((*SailingGenerateEventRPCRequest)(nil), "proto.SailingGenerateEventRPCRequest")
	proto.RegisterType((*SailingGenerateEventRPCResponse)(nil), "proto.SailingGenerateEventRPCResponse")
	proto.RegisterType((*SailingGenerateEventRPCResponse_Data)(nil), "proto.SailingGenerateEventRPCResponse.Data")
	proto.RegisterType((*SailingCheatRequestBase)(nil), "proto.SailingCheatRequestBase")
}

func init() { proto.RegisterFile("service/cross_sailing_cheat.proto", fileDescriptor_fd8cd560c6d74746) }

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

// SailingCheatServiceClient is the client API for SailingCheatService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type SailingCheatServiceClient interface {
	CreateDefaultActivity(ctx context.Context, in *SailingCreateDefaultActivityRPCRequest, opts ...grpc.CallOption) (*SailingCreateDefaultActivityRPCResponse, error)
	UnlockToArea(ctx context.Context, in *SailingUnlockToAreaRPCRequest, opts ...grpc.CallOption) (*SailingUnlockToAreaRPCResponse, error)
	ModifyHP(ctx context.Context, in *SailingModifyHPRPCRequest, opts ...grpc.CallOption) (*SailingModifyHPRPCResponse, error)
	ModifyStar(ctx context.Context, in *SailingModifyStarRPCRequest, opts ...grpc.CallOption) (*SailingModifyStarRPCResponse, error)
	ResetSwitchCD(ctx context.Context, in *SailingResetSwitchCDRPCRequest, opts ...grpc.CallOption) (*SailingResetSwitchCDRPCResponse, error)
	GenerateEvent(ctx context.Context, in *SailingGenerateEventRPCRequest, opts ...grpc.CallOption) (*SailingGenerateEventRPCResponse, error)
}

type sailingCheatServiceClient struct {
	cc *grpc.ClientConn
}

func NewSailingCheatServiceClient(cc *grpc.ClientConn) SailingCheatServiceClient {
	return &sailingCheatServiceClient{cc}
}

func (c *sailingCheatServiceClient) CreateDefaultActivity(ctx context.Context, in *SailingCreateDefaultActivityRPCRequest, opts ...grpc.CallOption) (*SailingCreateDefaultActivityRPCResponse, error) {
	out := new(SailingCreateDefaultActivityRPCResponse)
	err := c.cc.Invoke(ctx, "/proto.SailingCheatService/CreateDefaultActivity", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sailingCheatServiceClient) UnlockToArea(ctx context.Context, in *SailingUnlockToAreaRPCRequest, opts ...grpc.CallOption) (*SailingUnlockToAreaRPCResponse, error) {
	out := new(SailingUnlockToAreaRPCResponse)
	err := c.cc.Invoke(ctx, "/proto.SailingCheatService/UnlockToArea", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sailingCheatServiceClient) ModifyHP(ctx context.Context, in *SailingModifyHPRPCRequest, opts ...grpc.CallOption) (*SailingModifyHPRPCResponse, error) {
	out := new(SailingModifyHPRPCResponse)
	err := c.cc.Invoke(ctx, "/proto.SailingCheatService/ModifyHP", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sailingCheatServiceClient) ModifyStar(ctx context.Context, in *SailingModifyStarRPCRequest, opts ...grpc.CallOption) (*SailingModifyStarRPCResponse, error) {
	out := new(SailingModifyStarRPCResponse)
	err := c.cc.Invoke(ctx, "/proto.SailingCheatService/ModifyStar", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sailingCheatServiceClient) ResetSwitchCD(ctx context.Context, in *SailingResetSwitchCDRPCRequest, opts ...grpc.CallOption) (*SailingResetSwitchCDRPCResponse, error) {
	out := new(SailingResetSwitchCDRPCResponse)
	err := c.cc.Invoke(ctx, "/proto.SailingCheatService/ResetSwitchCD", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sailingCheatServiceClient) GenerateEvent(ctx context.Context, in *SailingGenerateEventRPCRequest, opts ...grpc.CallOption) (*SailingGenerateEventRPCResponse, error) {
	out := new(SailingGenerateEventRPCResponse)
	err := c.cc.Invoke(ctx, "/proto.SailingCheatService/GenerateEvent", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SailingCheatServiceServer is the server API for SailingCheatService service.
type SailingCheatServiceServer interface {
	CreateDefaultActivity(context.Context, *SailingCreateDefaultActivityRPCRequest) (*SailingCreateDefaultActivityRPCResponse, error)
	UnlockToArea(context.Context, *SailingUnlockToAreaRPCRequest) (*SailingUnlockToAreaRPCResponse, error)
	ModifyHP(context.Context, *SailingModifyHPRPCRequest) (*SailingModifyHPRPCResponse, error)
	ModifyStar(context.Context, *SailingModifyStarRPCRequest) (*SailingModifyStarRPCResponse, error)
	ResetSwitchCD(context.Context, *SailingResetSwitchCDRPCRequest) (*SailingResetSwitchCDRPCResponse, error)
	GenerateEvent(context.Context, *SailingGenerateEventRPCRequest) (*SailingGenerateEventRPCResponse, error)
}

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

func (*UnimplementedSailingCheatServiceServer) CreateDefaultActivity(ctx context.Context, req *SailingCreateDefaultActivityRPCRequest) (*SailingCreateDefaultActivityRPCResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateDefaultActivity not implemented")
}
func (*UnimplementedSailingCheatServiceServer) UnlockToArea(ctx context.Context, req *SailingUnlockToAreaRPCRequest) (*SailingUnlockToAreaRPCResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UnlockToArea not implemented")
}
func (*UnimplementedSailingCheatServiceServer) ModifyHP(ctx context.Context, req *SailingModifyHPRPCRequest) (*SailingModifyHPRPCResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifyHP not implemented")
}
func (*UnimplementedSailingCheatServiceServer) ModifyStar(ctx context.Context, req *SailingModifyStarRPCRequest) (*SailingModifyStarRPCResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifyStar not implemented")
}
func (*UnimplementedSailingCheatServiceServer) ResetSwitchCD(ctx context.Context, req *SailingResetSwitchCDRPCRequest) (*SailingResetSwitchCDRPCResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResetSwitchCD not implemented")
}
func (*UnimplementedSailingCheatServiceServer) GenerateEvent(ctx context.Context, req *SailingGenerateEventRPCRequest) (*SailingGenerateEventRPCResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateEvent not implemented")
}

func RegisterSailingCheatServiceServer(s *grpc.Server, srv SailingCheatServiceServer) {
	s.RegisterService(&_SailingCheatService_serviceDesc, srv)
}

func _SailingCheatService_CreateDefaultActivity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SailingCreateDefaultActivityRPCRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SailingCheatServiceServer).CreateDefaultActivity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.SailingCheatService/CreateDefaultActivity",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SailingCheatServiceServer).CreateDefaultActivity(ctx, req.(*SailingCreateDefaultActivityRPCRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SailingCheatService_UnlockToArea_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SailingUnlockToAreaRPCRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SailingCheatServiceServer).UnlockToArea(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.SailingCheatService/UnlockToArea",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SailingCheatServiceServer).UnlockToArea(ctx, req.(*SailingUnlockToAreaRPCRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SailingCheatService_ModifyHP_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SailingModifyHPRPCRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SailingCheatServiceServer).ModifyHP(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.SailingCheatService/ModifyHP",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SailingCheatServiceServer).ModifyHP(ctx, req.(*SailingModifyHPRPCRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SailingCheatService_ModifyStar_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SailingModifyStarRPCRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SailingCheatServiceServer).ModifyStar(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.SailingCheatService/ModifyStar",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SailingCheatServiceServer).ModifyStar(ctx, req.(*SailingModifyStarRPCRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SailingCheatService_ResetSwitchCD_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SailingResetSwitchCDRPCRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SailingCheatServiceServer).ResetSwitchCD(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.SailingCheatService/ResetSwitchCD",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SailingCheatServiceServer).ResetSwitchCD(ctx, req.(*SailingResetSwitchCDRPCRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SailingCheatService_GenerateEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SailingGenerateEventRPCRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SailingCheatServiceServer).GenerateEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/proto.SailingCheatService/GenerateEvent",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SailingCheatServiceServer).GenerateEvent(ctx, req.(*SailingGenerateEventRPCRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _SailingCheatService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "proto.SailingCheatService",
	HandlerType: (*SailingCheatServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateDefaultActivity",
			Handler:    _SailingCheatService_CreateDefaultActivity_Handler,
		},
		{
			MethodName: "UnlockToArea",
			Handler:    _SailingCheatService_UnlockToArea_Handler,
		},
		{
			MethodName: "ModifyHP",
			Handler:    _SailingCheatService_ModifyHP_Handler,
		},
		{
			MethodName: "ModifyStar",
			Handler:    _SailingCheatService_ModifyStar_Handler,
		},
		{
			MethodName: "ResetSwitchCD",
			Handler:    _SailingCheatService_ResetSwitchCD_Handler,
		},
		{
			MethodName: "GenerateEvent",
			Handler:    _SailingCheatService_GenerateEvent_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "service/cross_sailing_cheat.proto",
}
