// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.20.0
// source: game_server_rpc.proto

package gsrpc

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

// GmGameServerRpcClient is the client API for GmGameServerRpc service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type GmGameServerRpcClient interface {
	//通用gm，string格式转发到游服，避免添加命令修改多个项目
	SendGM(ctx context.Context, in *GmSendGMReq, opts ...grpc.CallOption) (*GmSendGMResp, error)
}

type gmGameServerRpcClient struct {
	cc grpc.ClientConnInterface
}

func NewGmGameServerRpcClient(cc grpc.ClientConnInterface) GmGameServerRpcClient {
	return &gmGameServerRpcClient{cc}
}

func (c *gmGameServerRpcClient) SendGM(ctx context.Context, in *GmSendGMReq, opts ...grpc.CallOption) (*GmSendGMResp, error) {
	out := new(GmSendGMResp)
	err := c.cc.Invoke(ctx, "/gsrpc.GmGameServerRpc/sendGM", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GmGameServerRpcServer is the server API for GmGameServerRpc service.
// All implementations must embed UnimplementedGmGameServerRpcServer
// for forward compatibility
type GmGameServerRpcServer interface {
	//通用gm，string格式转发到游服，避免添加命令修改多个项目
	SendGM(context.Context, *GmSendGMReq) (*GmSendGMResp, error)
	mustEmbedUnimplementedGmGameServerRpcServer()
}

// UnimplementedGmGameServerRpcServer must be embedded to have forward compatible implementations.
type UnimplementedGmGameServerRpcServer struct {
}

func (UnimplementedGmGameServerRpcServer) SendGM(context.Context, *GmSendGMReq) (*GmSendGMResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendGM not implemented")
}
func (UnimplementedGmGameServerRpcServer) mustEmbedUnimplementedGmGameServerRpcServer() {}

// UnsafeGmGameServerRpcServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to GmGameServerRpcServer will
// result in compilation errors.
type UnsafeGmGameServerRpcServer interface {
	mustEmbedUnimplementedGmGameServerRpcServer()
}

func RegisterGmGameServerRpcServer(s grpc.ServiceRegistrar, srv GmGameServerRpcServer) {
	s.RegisterService(&GmGameServerRpc_ServiceDesc, srv)
}

func _GmGameServerRpc_SendGM_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GmSendGMReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GmGameServerRpcServer).SendGM(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.GmGameServerRpc/sendGM",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GmGameServerRpcServer).SendGM(ctx, req.(*GmSendGMReq))
	}
	return interceptor(ctx, in, info, handler)
}

// GmGameServerRpc_ServiceDesc is the grpc.ServiceDesc for GmGameServerRpc service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GmGameServerRpc_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gsrpc.GmGameServerRpc",
	HandlerType: (*GmGameServerRpcServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "sendGM",
			Handler:    _GmGameServerRpc_SendGM_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "game_server_rpc.proto",
}

// ServerService2Client is the client API for ServerService2 service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type ServerService2Client interface {
	// 发送邮件
	SendRoleMail(ctx context.Context, in *ServerArgsSendRoleMail, opts ...grpc.CallOption) (*ServerReplySendRoleMail, error)
	// 导出数据
	ExportRoleData(ctx context.Context, in *ExportRoleDataIn, opts ...grpc.CallOption) (*ExportRoleDataOut, error)
	// 导入数据
	ImportRoleData(ctx context.Context, in *ImportRoleDataIn, opts ...grpc.CallOption) (*ImportRoleDataOut, error)
	// 发送区服邮件
	SendServMail(ctx context.Context, in *ServerArgsSendServMail, opts ...grpc.CallOption) (*ServerReplySendServMail, error)
	// 禁言
	ForbidChat(ctx context.Context, in *ServerArgsForbidChat, opts ...grpc.CallOption) (*ServerReplyForbidChat, error)
	// 充值推送
	//rpc rechargePush (ServerArgsRechargePush) returns (ServerReplyRechargePush);
	// 时间跳跃
	TimeJump(ctx context.Context, in *ServerArgsTimeJump, opts ...grpc.CallOption) (*ServerReplyTimeJump, error)
	GsSyncInfo(ctx context.Context, in *GsInfoReq, opts ...grpc.CallOption) (*GsInfoResp, error)
}

type serverService2Client struct {
	cc grpc.ClientConnInterface
}

func NewServerService2Client(cc grpc.ClientConnInterface) ServerService2Client {
	return &serverService2Client{cc}
}

func (c *serverService2Client) SendRoleMail(ctx context.Context, in *ServerArgsSendRoleMail, opts ...grpc.CallOption) (*ServerReplySendRoleMail, error) {
	out := new(ServerReplySendRoleMail)
	err := c.cc.Invoke(ctx, "/gsrpc.ServerService2/sendRoleMail", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverService2Client) ExportRoleData(ctx context.Context, in *ExportRoleDataIn, opts ...grpc.CallOption) (*ExportRoleDataOut, error) {
	out := new(ExportRoleDataOut)
	err := c.cc.Invoke(ctx, "/gsrpc.ServerService2/exportRoleData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverService2Client) ImportRoleData(ctx context.Context, in *ImportRoleDataIn, opts ...grpc.CallOption) (*ImportRoleDataOut, error) {
	out := new(ImportRoleDataOut)
	err := c.cc.Invoke(ctx, "/gsrpc.ServerService2/importRoleData", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverService2Client) SendServMail(ctx context.Context, in *ServerArgsSendServMail, opts ...grpc.CallOption) (*ServerReplySendServMail, error) {
	out := new(ServerReplySendServMail)
	err := c.cc.Invoke(ctx, "/gsrpc.ServerService2/sendServMail", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverService2Client) ForbidChat(ctx context.Context, in *ServerArgsForbidChat, opts ...grpc.CallOption) (*ServerReplyForbidChat, error) {
	out := new(ServerReplyForbidChat)
	err := c.cc.Invoke(ctx, "/gsrpc.ServerService2/forbidChat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverService2Client) TimeJump(ctx context.Context, in *ServerArgsTimeJump, opts ...grpc.CallOption) (*ServerReplyTimeJump, error) {
	out := new(ServerReplyTimeJump)
	err := c.cc.Invoke(ctx, "/gsrpc.ServerService2/timeJump", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverService2Client) GsSyncInfo(ctx context.Context, in *GsInfoReq, opts ...grpc.CallOption) (*GsInfoResp, error) {
	out := new(GsInfoResp)
	err := c.cc.Invoke(ctx, "/gsrpc.ServerService2/gsSyncInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerService2Server is the server API for ServerService2 service.
// All implementations must embed UnimplementedServerService2Server
// for forward compatibility
type ServerService2Server interface {
	// 发送邮件
	SendRoleMail(context.Context, *ServerArgsSendRoleMail) (*ServerReplySendRoleMail, error)
	// 导出数据
	ExportRoleData(context.Context, *ExportRoleDataIn) (*ExportRoleDataOut, error)
	// 导入数据
	ImportRoleData(context.Context, *ImportRoleDataIn) (*ImportRoleDataOut, error)
	// 发送区服邮件
	SendServMail(context.Context, *ServerArgsSendServMail) (*ServerReplySendServMail, error)
	// 禁言
	ForbidChat(context.Context, *ServerArgsForbidChat) (*ServerReplyForbidChat, error)
	// 充值推送
	//rpc rechargePush (ServerArgsRechargePush) returns (ServerReplyRechargePush);
	// 时间跳跃
	TimeJump(context.Context, *ServerArgsTimeJump) (*ServerReplyTimeJump, error)
	GsSyncInfo(context.Context, *GsInfoReq) (*GsInfoResp, error)
	mustEmbedUnimplementedServerService2Server()
}

// UnimplementedServerService2Server must be embedded to have forward compatible implementations.
type UnimplementedServerService2Server struct {
}

func (UnimplementedServerService2Server) SendRoleMail(context.Context, *ServerArgsSendRoleMail) (*ServerReplySendRoleMail, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendRoleMail not implemented")
}
func (UnimplementedServerService2Server) ExportRoleData(context.Context, *ExportRoleDataIn) (*ExportRoleDataOut, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExportRoleData not implemented")
}
func (UnimplementedServerService2Server) ImportRoleData(context.Context, *ImportRoleDataIn) (*ImportRoleDataOut, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ImportRoleData not implemented")
}
func (UnimplementedServerService2Server) SendServMail(context.Context, *ServerArgsSendServMail) (*ServerReplySendServMail, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SendServMail not implemented")
}
func (UnimplementedServerService2Server) ForbidChat(context.Context, *ServerArgsForbidChat) (*ServerReplyForbidChat, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ForbidChat not implemented")
}
func (UnimplementedServerService2Server) TimeJump(context.Context, *ServerArgsTimeJump) (*ServerReplyTimeJump, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TimeJump not implemented")
}
func (UnimplementedServerService2Server) GsSyncInfo(context.Context, *GsInfoReq) (*GsInfoResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GsSyncInfo not implemented")
}
func (UnimplementedServerService2Server) mustEmbedUnimplementedServerService2Server() {}

// UnsafeServerService2Server may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to ServerService2Server will
// result in compilation errors.
type UnsafeServerService2Server interface {
	mustEmbedUnimplementedServerService2Server()
}

func RegisterServerService2Server(s grpc.ServiceRegistrar, srv ServerService2Server) {
	s.RegisterService(&ServerService2_ServiceDesc, srv)
}

func _ServerService2_SendRoleMail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerArgsSendRoleMail)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerService2Server).SendRoleMail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.ServerService2/sendRoleMail",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerService2Server).SendRoleMail(ctx, req.(*ServerArgsSendRoleMail))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerService2_ExportRoleData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExportRoleDataIn)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerService2Server).ExportRoleData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.ServerService2/exportRoleData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerService2Server).ExportRoleData(ctx, req.(*ExportRoleDataIn))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerService2_ImportRoleData_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportRoleDataIn)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerService2Server).ImportRoleData(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.ServerService2/importRoleData",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerService2Server).ImportRoleData(ctx, req.(*ImportRoleDataIn))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerService2_SendServMail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerArgsSendServMail)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerService2Server).SendServMail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.ServerService2/sendServMail",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerService2Server).SendServMail(ctx, req.(*ServerArgsSendServMail))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerService2_ForbidChat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerArgsForbidChat)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerService2Server).ForbidChat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.ServerService2/forbidChat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerService2Server).ForbidChat(ctx, req.(*ServerArgsForbidChat))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerService2_TimeJump_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServerArgsTimeJump)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerService2Server).TimeJump(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.ServerService2/timeJump",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerService2Server).TimeJump(ctx, req.(*ServerArgsTimeJump))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerService2_GsSyncInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GsInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerService2Server).GsSyncInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.ServerService2/gsSyncInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerService2Server).GsSyncInfo(ctx, req.(*GsInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerService2_ServiceDesc is the grpc.ServiceDesc for ServerService2 service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerService2_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gsrpc.ServerService2",
	HandlerType: (*ServerService2Server)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "sendRoleMail",
			Handler:    _ServerService2_SendRoleMail_Handler,
		},
		{
			MethodName: "exportRoleData",
			Handler:    _ServerService2_ExportRoleData_Handler,
		},
		{
			MethodName: "importRoleData",
			Handler:    _ServerService2_ImportRoleData_Handler,
		},
		{
			MethodName: "sendServMail",
			Handler:    _ServerService2_SendServMail_Handler,
		},
		{
			MethodName: "forbidChat",
			Handler:    _ServerService2_ForbidChat_Handler,
		},
		{
			MethodName: "timeJump",
			Handler:    _ServerService2_TimeJump_Handler,
		},
		{
			MethodName: "gsSyncInfo",
			Handler:    _ServerService2_GsSyncInfo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "game_server_rpc.proto",
}

// RechargeGameServerRpcClient is the client API for RechargeGameServerRpc service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type RechargeGameServerRpcClient interface {
	// 充值-发货
	Delive(ctx context.Context, in *RechargeDeliveReq, opts ...grpc.CallOption) (*RechargeDeliveResp, error)
	// 充值-礼包
	AddGift(ctx context.Context, in *RechargeGiftReq, opts ...grpc.CallOption) (*RechargeGiftResp, error)
}

type rechargeGameServerRpcClient struct {
	cc grpc.ClientConnInterface
}

func NewRechargeGameServerRpcClient(cc grpc.ClientConnInterface) RechargeGameServerRpcClient {
	return &rechargeGameServerRpcClient{cc}
}

func (c *rechargeGameServerRpcClient) Delive(ctx context.Context, in *RechargeDeliveReq, opts ...grpc.CallOption) (*RechargeDeliveResp, error) {
	out := new(RechargeDeliveResp)
	err := c.cc.Invoke(ctx, "/gsrpc.RechargeGameServerRpc/delive", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *rechargeGameServerRpcClient) AddGift(ctx context.Context, in *RechargeGiftReq, opts ...grpc.CallOption) (*RechargeGiftResp, error) {
	out := new(RechargeGiftResp)
	err := c.cc.Invoke(ctx, "/gsrpc.RechargeGameServerRpc/addGift", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RechargeGameServerRpcServer is the server API for RechargeGameServerRpc service.
// All implementations must embed UnimplementedRechargeGameServerRpcServer
// for forward compatibility
type RechargeGameServerRpcServer interface {
	// 充值-发货
	Delive(context.Context, *RechargeDeliveReq) (*RechargeDeliveResp, error)
	// 充值-礼包
	AddGift(context.Context, *RechargeGiftReq) (*RechargeGiftResp, error)
	mustEmbedUnimplementedRechargeGameServerRpcServer()
}

// UnimplementedRechargeGameServerRpcServer must be embedded to have forward compatible implementations.
type UnimplementedRechargeGameServerRpcServer struct {
}

func (UnimplementedRechargeGameServerRpcServer) Delive(context.Context, *RechargeDeliveReq) (*RechargeDeliveResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delive not implemented")
}
func (UnimplementedRechargeGameServerRpcServer) AddGift(context.Context, *RechargeGiftReq) (*RechargeGiftResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddGift not implemented")
}
func (UnimplementedRechargeGameServerRpcServer) mustEmbedUnimplementedRechargeGameServerRpcServer() {}

// UnsafeRechargeGameServerRpcServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to RechargeGameServerRpcServer will
// result in compilation errors.
type UnsafeRechargeGameServerRpcServer interface {
	mustEmbedUnimplementedRechargeGameServerRpcServer()
}

func RegisterRechargeGameServerRpcServer(s grpc.ServiceRegistrar, srv RechargeGameServerRpcServer) {
	s.RegisterService(&RechargeGameServerRpc_ServiceDesc, srv)
}

func _RechargeGameServerRpc_Delive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RechargeDeliveReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RechargeGameServerRpcServer).Delive(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.RechargeGameServerRpc/delive",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RechargeGameServerRpcServer).Delive(ctx, req.(*RechargeDeliveReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RechargeGameServerRpc_AddGift_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RechargeGiftReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RechargeGameServerRpcServer).AddGift(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gsrpc.RechargeGameServerRpc/addGift",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RechargeGameServerRpcServer).AddGift(ctx, req.(*RechargeGiftReq))
	}
	return interceptor(ctx, in, info, handler)
}

// RechargeGameServerRpc_ServiceDesc is the grpc.ServiceDesc for RechargeGameServerRpc service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var RechargeGameServerRpc_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "gsrpc.RechargeGameServerRpc",
	HandlerType: (*RechargeGameServerRpcServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "delive",
			Handler:    _RechargeGameServerRpc_Delive_Handler,
		},
		{
			MethodName: "addGift",
			Handler:    _RechargeGameServerRpc_AddGift_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "game_server_rpc.proto",
}