// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.6.2
// - protoc             v7.35.0
// source: proto/game/v1/game.proto

package gamev1

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.64.0 or later.
const _ = grpc.SupportPackageIsVersion9

const (
	GameAppService_ListGames_FullMethodName              = "/hyapp.game.v1.GameAppService/ListGames"
	GameAppService_ListRecentGames_FullMethodName        = "/hyapp.game.v1.GameAppService/ListRecentGames"
	GameAppService_ListExploreWinners_FullMethodName     = "/hyapp.game.v1.GameAppService/ListExploreWinners"
	GameAppService_GetBridgeScript_FullMethodName        = "/hyapp.game.v1.GameAppService/GetBridgeScript"
	GameAppService_LaunchGame_FullMethodName             = "/hyapp.game.v1.GameAppService/LaunchGame"
	GameAppService_GetDiceConfig_FullMethodName          = "/hyapp.game.v1.GameAppService/GetDiceConfig"
	GameAppService_MatchDice_FullMethodName              = "/hyapp.game.v1.GameAppService/MatchDice"
	GameAppService_CreateDiceMatch_FullMethodName        = "/hyapp.game.v1.GameAppService/CreateDiceMatch"
	GameAppService_JoinDiceMatch_FullMethodName          = "/hyapp.game.v1.GameAppService/JoinDiceMatch"
	GameAppService_GetDiceMatch_FullMethodName           = "/hyapp.game.v1.GameAppService/GetDiceMatch"
	GameAppService_RollDiceMatch_FullMethodName          = "/hyapp.game.v1.GameAppService/RollDiceMatch"
	GameAppService_CancelDiceMatch_FullMethodName        = "/hyapp.game.v1.GameAppService/CancelDiceMatch"
	GameAppService_GetRoomRPSConfig_FullMethodName       = "/hyapp.game.v1.GameAppService/GetRoomRPSConfig"
	GameAppService_ListRoomRPSChallenges_FullMethodName  = "/hyapp.game.v1.GameAppService/ListRoomRPSChallenges"
	GameAppService_CreateRoomRPSChallenge_FullMethodName = "/hyapp.game.v1.GameAppService/CreateRoomRPSChallenge"
	GameAppService_AcceptRoomRPSChallenge_FullMethodName = "/hyapp.game.v1.GameAppService/AcceptRoomRPSChallenge"
	GameAppService_GetRoomRPSChallenge_FullMethodName    = "/hyapp.game.v1.GameAppService/GetRoomRPSChallenge"
)

// GameAppServiceClient is the client API for GameAppService 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 GameAppServiceClient interface {
	ListGames(ctx context.Context, in *ListGamesRequest, opts ...grpc.CallOption) (*ListGamesResponse, error)
	ListRecentGames(ctx context.Context, in *ListRecentGamesRequest, opts ...grpc.CallOption) (*ListGamesResponse, error)
	ListExploreWinners(ctx context.Context, in *ListExploreWinnersRequest, opts ...grpc.CallOption) (*ListExploreWinnersResponse, error)
	GetBridgeScript(ctx context.Context, in *GetBridgeScriptRequest, opts ...grpc.CallOption) (*GetBridgeScriptResponse, error)
	LaunchGame(ctx context.Context, in *LaunchGameRequest, opts ...grpc.CallOption) (*LaunchGameResponse, error)
	GetDiceConfig(ctx context.Context, in *GetDiceConfigRequest, opts ...grpc.CallOption) (*DiceConfigResponse, error)
	MatchDice(ctx context.Context, in *MatchDiceRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error)
	CreateDiceMatch(ctx context.Context, in *CreateDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error)
	JoinDiceMatch(ctx context.Context, in *JoinDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error)
	GetDiceMatch(ctx context.Context, in *GetDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error)
	RollDiceMatch(ctx context.Context, in *RollDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error)
	CancelDiceMatch(ctx context.Context, in *CancelDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error)
	GetRoomRPSConfig(ctx context.Context, in *GetRoomRPSConfigRequest, opts ...grpc.CallOption) (*RoomRPSConfigResponse, error)
	ListRoomRPSChallenges(ctx context.Context, in *ListRoomRPSChallengesRequest, opts ...grpc.CallOption) (*ListRoomRPSChallengesResponse, error)
	CreateRoomRPSChallenge(ctx context.Context, in *CreateRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error)
	AcceptRoomRPSChallenge(ctx context.Context, in *AcceptRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error)
	GetRoomRPSChallenge(ctx context.Context, in *GetRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error)
}

type gameAppServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGameAppServiceClient(cc grpc.ClientConnInterface) GameAppServiceClient {
	return &gameAppServiceClient{cc}
}

func (c *gameAppServiceClient) ListGames(ctx context.Context, in *ListGamesRequest, opts ...grpc.CallOption) (*ListGamesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListGamesResponse)
	err := c.cc.Invoke(ctx, GameAppService_ListGames_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) ListRecentGames(ctx context.Context, in *ListRecentGamesRequest, opts ...grpc.CallOption) (*ListGamesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListGamesResponse)
	err := c.cc.Invoke(ctx, GameAppService_ListRecentGames_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) ListExploreWinners(ctx context.Context, in *ListExploreWinnersRequest, opts ...grpc.CallOption) (*ListExploreWinnersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListExploreWinnersResponse)
	err := c.cc.Invoke(ctx, GameAppService_ListExploreWinners_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) GetBridgeScript(ctx context.Context, in *GetBridgeScriptRequest, opts ...grpc.CallOption) (*GetBridgeScriptResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetBridgeScriptResponse)
	err := c.cc.Invoke(ctx, GameAppService_GetBridgeScript_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) LaunchGame(ctx context.Context, in *LaunchGameRequest, opts ...grpc.CallOption) (*LaunchGameResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(LaunchGameResponse)
	err := c.cc.Invoke(ctx, GameAppService_LaunchGame_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) GetDiceConfig(ctx context.Context, in *GetDiceConfigRequest, opts ...grpc.CallOption) (*DiceConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceConfigResponse)
	err := c.cc.Invoke(ctx, GameAppService_GetDiceConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) MatchDice(ctx context.Context, in *MatchDiceRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceMatchResponse)
	err := c.cc.Invoke(ctx, GameAppService_MatchDice_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) CreateDiceMatch(ctx context.Context, in *CreateDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceMatchResponse)
	err := c.cc.Invoke(ctx, GameAppService_CreateDiceMatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) JoinDiceMatch(ctx context.Context, in *JoinDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceMatchResponse)
	err := c.cc.Invoke(ctx, GameAppService_JoinDiceMatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) GetDiceMatch(ctx context.Context, in *GetDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceMatchResponse)
	err := c.cc.Invoke(ctx, GameAppService_GetDiceMatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) RollDiceMatch(ctx context.Context, in *RollDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceMatchResponse)
	err := c.cc.Invoke(ctx, GameAppService_RollDiceMatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) CancelDiceMatch(ctx context.Context, in *CancelDiceMatchRequest, opts ...grpc.CallOption) (*DiceMatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceMatchResponse)
	err := c.cc.Invoke(ctx, GameAppService_CancelDiceMatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) GetRoomRPSConfig(ctx context.Context, in *GetRoomRPSConfigRequest, opts ...grpc.CallOption) (*RoomRPSConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSConfigResponse)
	err := c.cc.Invoke(ctx, GameAppService_GetRoomRPSConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) ListRoomRPSChallenges(ctx context.Context, in *ListRoomRPSChallengesRequest, opts ...grpc.CallOption) (*ListRoomRPSChallengesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListRoomRPSChallengesResponse)
	err := c.cc.Invoke(ctx, GameAppService_ListRoomRPSChallenges_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) CreateRoomRPSChallenge(ctx context.Context, in *CreateRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSChallengeResponse)
	err := c.cc.Invoke(ctx, GameAppService_CreateRoomRPSChallenge_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) AcceptRoomRPSChallenge(ctx context.Context, in *AcceptRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSChallengeResponse)
	err := c.cc.Invoke(ctx, GameAppService_AcceptRoomRPSChallenge_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAppServiceClient) GetRoomRPSChallenge(ctx context.Context, in *GetRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSChallengeResponse)
	err := c.cc.Invoke(ctx, GameAppService_GetRoomRPSChallenge_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GameAppServiceServer is the server API for GameAppService service.
// All implementations must embed UnimplementedGameAppServiceServer
// for forward compatibility.
type GameAppServiceServer interface {
	ListGames(context.Context, *ListGamesRequest) (*ListGamesResponse, error)
	ListRecentGames(context.Context, *ListRecentGamesRequest) (*ListGamesResponse, error)
	ListExploreWinners(context.Context, *ListExploreWinnersRequest) (*ListExploreWinnersResponse, error)
	GetBridgeScript(context.Context, *GetBridgeScriptRequest) (*GetBridgeScriptResponse, error)
	LaunchGame(context.Context, *LaunchGameRequest) (*LaunchGameResponse, error)
	GetDiceConfig(context.Context, *GetDiceConfigRequest) (*DiceConfigResponse, error)
	MatchDice(context.Context, *MatchDiceRequest) (*DiceMatchResponse, error)
	CreateDiceMatch(context.Context, *CreateDiceMatchRequest) (*DiceMatchResponse, error)
	JoinDiceMatch(context.Context, *JoinDiceMatchRequest) (*DiceMatchResponse, error)
	GetDiceMatch(context.Context, *GetDiceMatchRequest) (*DiceMatchResponse, error)
	RollDiceMatch(context.Context, *RollDiceMatchRequest) (*DiceMatchResponse, error)
	CancelDiceMatch(context.Context, *CancelDiceMatchRequest) (*DiceMatchResponse, error)
	GetRoomRPSConfig(context.Context, *GetRoomRPSConfigRequest) (*RoomRPSConfigResponse, error)
	ListRoomRPSChallenges(context.Context, *ListRoomRPSChallengesRequest) (*ListRoomRPSChallengesResponse, error)
	CreateRoomRPSChallenge(context.Context, *CreateRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error)
	AcceptRoomRPSChallenge(context.Context, *AcceptRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error)
	GetRoomRPSChallenge(context.Context, *GetRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error)
	mustEmbedUnimplementedGameAppServiceServer()
}

// UnimplementedGameAppServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedGameAppServiceServer struct{}

func (UnimplementedGameAppServiceServer) ListGames(context.Context, *ListGamesRequest) (*ListGamesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListGames not implemented")
}
func (UnimplementedGameAppServiceServer) ListRecentGames(context.Context, *ListRecentGamesRequest) (*ListGamesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListRecentGames not implemented")
}
func (UnimplementedGameAppServiceServer) ListExploreWinners(context.Context, *ListExploreWinnersRequest) (*ListExploreWinnersResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListExploreWinners not implemented")
}
func (UnimplementedGameAppServiceServer) GetBridgeScript(context.Context, *GetBridgeScriptRequest) (*GetBridgeScriptResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetBridgeScript not implemented")
}
func (UnimplementedGameAppServiceServer) LaunchGame(context.Context, *LaunchGameRequest) (*LaunchGameResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method LaunchGame not implemented")
}
func (UnimplementedGameAppServiceServer) GetDiceConfig(context.Context, *GetDiceConfigRequest) (*DiceConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetDiceConfig not implemented")
}
func (UnimplementedGameAppServiceServer) MatchDice(context.Context, *MatchDiceRequest) (*DiceMatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method MatchDice not implemented")
}
func (UnimplementedGameAppServiceServer) CreateDiceMatch(context.Context, *CreateDiceMatchRequest) (*DiceMatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateDiceMatch not implemented")
}
func (UnimplementedGameAppServiceServer) JoinDiceMatch(context.Context, *JoinDiceMatchRequest) (*DiceMatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method JoinDiceMatch not implemented")
}
func (UnimplementedGameAppServiceServer) GetDiceMatch(context.Context, *GetDiceMatchRequest) (*DiceMatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetDiceMatch not implemented")
}
func (UnimplementedGameAppServiceServer) RollDiceMatch(context.Context, *RollDiceMatchRequest) (*DiceMatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method RollDiceMatch not implemented")
}
func (UnimplementedGameAppServiceServer) CancelDiceMatch(context.Context, *CancelDiceMatchRequest) (*DiceMatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CancelDiceMatch not implemented")
}
func (UnimplementedGameAppServiceServer) GetRoomRPSConfig(context.Context, *GetRoomRPSConfigRequest) (*RoomRPSConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRoomRPSConfig not implemented")
}
func (UnimplementedGameAppServiceServer) ListRoomRPSChallenges(context.Context, *ListRoomRPSChallengesRequest) (*ListRoomRPSChallengesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListRoomRPSChallenges not implemented")
}
func (UnimplementedGameAppServiceServer) CreateRoomRPSChallenge(context.Context, *CreateRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method CreateRoomRPSChallenge not implemented")
}
func (UnimplementedGameAppServiceServer) AcceptRoomRPSChallenge(context.Context, *AcceptRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method AcceptRoomRPSChallenge not implemented")
}
func (UnimplementedGameAppServiceServer) GetRoomRPSChallenge(context.Context, *GetRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRoomRPSChallenge not implemented")
}
func (UnimplementedGameAppServiceServer) mustEmbedUnimplementedGameAppServiceServer() {}
func (UnimplementedGameAppServiceServer) testEmbeddedByValue()                        {}

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

func RegisterGameAppServiceServer(s grpc.ServiceRegistrar, srv GameAppServiceServer) {
	// If the following call panics, it indicates UnimplementedGameAppServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&GameAppService_ServiceDesc, srv)
}

func _GameAppService_ListGames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListGamesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).ListGames(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_ListGames_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).ListGames(ctx, req.(*ListGamesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_ListRecentGames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRecentGamesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).ListRecentGames(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_ListRecentGames_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).ListRecentGames(ctx, req.(*ListRecentGamesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_ListExploreWinners_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListExploreWinnersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).ListExploreWinners(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_ListExploreWinners_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).ListExploreWinners(ctx, req.(*ListExploreWinnersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_GetBridgeScript_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBridgeScriptRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).GetBridgeScript(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_GetBridgeScript_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).GetBridgeScript(ctx, req.(*GetBridgeScriptRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_LaunchGame_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LaunchGameRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).LaunchGame(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_LaunchGame_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).LaunchGame(ctx, req.(*LaunchGameRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_GetDiceConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDiceConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).GetDiceConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_GetDiceConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).GetDiceConfig(ctx, req.(*GetDiceConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_MatchDice_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MatchDiceRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).MatchDice(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_MatchDice_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).MatchDice(ctx, req.(*MatchDiceRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_CreateDiceMatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateDiceMatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).CreateDiceMatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_CreateDiceMatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).CreateDiceMatch(ctx, req.(*CreateDiceMatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_JoinDiceMatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JoinDiceMatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).JoinDiceMatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_JoinDiceMatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).JoinDiceMatch(ctx, req.(*JoinDiceMatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_GetDiceMatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDiceMatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).GetDiceMatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_GetDiceMatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).GetDiceMatch(ctx, req.(*GetDiceMatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_RollDiceMatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RollDiceMatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).RollDiceMatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_RollDiceMatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).RollDiceMatch(ctx, req.(*RollDiceMatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_CancelDiceMatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelDiceMatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).CancelDiceMatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_CancelDiceMatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).CancelDiceMatch(ctx, req.(*CancelDiceMatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_GetRoomRPSConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRoomRPSConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).GetRoomRPSConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_GetRoomRPSConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).GetRoomRPSConfig(ctx, req.(*GetRoomRPSConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_ListRoomRPSChallenges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRoomRPSChallengesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).ListRoomRPSChallenges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_ListRoomRPSChallenges_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).ListRoomRPSChallenges(ctx, req.(*ListRoomRPSChallengesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_CreateRoomRPSChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateRoomRPSChallengeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).CreateRoomRPSChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_CreateRoomRPSChallenge_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).CreateRoomRPSChallenge(ctx, req.(*CreateRoomRPSChallengeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_AcceptRoomRPSChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AcceptRoomRPSChallengeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).AcceptRoomRPSChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_AcceptRoomRPSChallenge_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).AcceptRoomRPSChallenge(ctx, req.(*AcceptRoomRPSChallengeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAppService_GetRoomRPSChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRoomRPSChallengeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAppServiceServer).GetRoomRPSChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAppService_GetRoomRPSChallenge_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAppServiceServer).GetRoomRPSChallenge(ctx, req.(*GetRoomRPSChallengeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GameAppService_ServiceDesc is the grpc.ServiceDesc for GameAppService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GameAppService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.game.v1.GameAppService",
	HandlerType: (*GameAppServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListGames",
			Handler:    _GameAppService_ListGames_Handler,
		},
		{
			MethodName: "ListRecentGames",
			Handler:    _GameAppService_ListRecentGames_Handler,
		},
		{
			MethodName: "ListExploreWinners",
			Handler:    _GameAppService_ListExploreWinners_Handler,
		},
		{
			MethodName: "GetBridgeScript",
			Handler:    _GameAppService_GetBridgeScript_Handler,
		},
		{
			MethodName: "LaunchGame",
			Handler:    _GameAppService_LaunchGame_Handler,
		},
		{
			MethodName: "GetDiceConfig",
			Handler:    _GameAppService_GetDiceConfig_Handler,
		},
		{
			MethodName: "MatchDice",
			Handler:    _GameAppService_MatchDice_Handler,
		},
		{
			MethodName: "CreateDiceMatch",
			Handler:    _GameAppService_CreateDiceMatch_Handler,
		},
		{
			MethodName: "JoinDiceMatch",
			Handler:    _GameAppService_JoinDiceMatch_Handler,
		},
		{
			MethodName: "GetDiceMatch",
			Handler:    _GameAppService_GetDiceMatch_Handler,
		},
		{
			MethodName: "RollDiceMatch",
			Handler:    _GameAppService_RollDiceMatch_Handler,
		},
		{
			MethodName: "CancelDiceMatch",
			Handler:    _GameAppService_CancelDiceMatch_Handler,
		},
		{
			MethodName: "GetRoomRPSConfig",
			Handler:    _GameAppService_GetRoomRPSConfig_Handler,
		},
		{
			MethodName: "ListRoomRPSChallenges",
			Handler:    _GameAppService_ListRoomRPSChallenges_Handler,
		},
		{
			MethodName: "CreateRoomRPSChallenge",
			Handler:    _GameAppService_CreateRoomRPSChallenge_Handler,
		},
		{
			MethodName: "AcceptRoomRPSChallenge",
			Handler:    _GameAppService_AcceptRoomRPSChallenge_Handler,
		},
		{
			MethodName: "GetRoomRPSChallenge",
			Handler:    _GameAppService_GetRoomRPSChallenge_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/game/v1/game.proto",
}

const (
	GameCallbackService_HandleCallback_FullMethodName = "/hyapp.game.v1.GameCallbackService/HandleCallback"
)

// GameCallbackServiceClient is the client API for GameCallbackService 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 GameCallbackServiceClient interface {
	HandleCallback(ctx context.Context, in *CallbackRequest, opts ...grpc.CallOption) (*CallbackResponse, error)
}

type gameCallbackServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGameCallbackServiceClient(cc grpc.ClientConnInterface) GameCallbackServiceClient {
	return &gameCallbackServiceClient{cc}
}

func (c *gameCallbackServiceClient) HandleCallback(ctx context.Context, in *CallbackRequest, opts ...grpc.CallOption) (*CallbackResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CallbackResponse)
	err := c.cc.Invoke(ctx, GameCallbackService_HandleCallback_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GameCallbackServiceServer is the server API for GameCallbackService service.
// All implementations must embed UnimplementedGameCallbackServiceServer
// for forward compatibility.
type GameCallbackServiceServer interface {
	HandleCallback(context.Context, *CallbackRequest) (*CallbackResponse, error)
	mustEmbedUnimplementedGameCallbackServiceServer()
}

// UnimplementedGameCallbackServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedGameCallbackServiceServer struct{}

func (UnimplementedGameCallbackServiceServer) HandleCallback(context.Context, *CallbackRequest) (*CallbackResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method HandleCallback not implemented")
}
func (UnimplementedGameCallbackServiceServer) mustEmbedUnimplementedGameCallbackServiceServer() {}
func (UnimplementedGameCallbackServiceServer) testEmbeddedByValue()                             {}

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

func RegisterGameCallbackServiceServer(s grpc.ServiceRegistrar, srv GameCallbackServiceServer) {
	// If the following call panics, it indicates UnimplementedGameCallbackServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&GameCallbackService_ServiceDesc, srv)
}

func _GameCallbackService_HandleCallback_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CallbackRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameCallbackServiceServer).HandleCallback(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameCallbackService_HandleCallback_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameCallbackServiceServer).HandleCallback(ctx, req.(*CallbackRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GameCallbackService_ServiceDesc is the grpc.ServiceDesc for GameCallbackService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GameCallbackService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.game.v1.GameCallbackService",
	HandlerType: (*GameCallbackServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "HandleCallback",
			Handler:    _GameCallbackService_HandleCallback_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/game/v1/game.proto",
}

const (
	GameCronService_ProcessLevelEventOutboxBatch_FullMethodName = "/hyapp.game.v1.GameCronService/ProcessLevelEventOutboxBatch"
)

// GameCronServiceClient is the client API for GameCronService 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.
//
// GameCronService 只给 cron-service 触发 game-service 拥有的补偿批处理。
type GameCronServiceClient interface {
	ProcessLevelEventOutboxBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error)
}

type gameCronServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGameCronServiceClient(cc grpc.ClientConnInterface) GameCronServiceClient {
	return &gameCronServiceClient{cc}
}

func (c *gameCronServiceClient) ProcessLevelEventOutboxBatch(ctx context.Context, in *CronBatchRequest, opts ...grpc.CallOption) (*CronBatchResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CronBatchResponse)
	err := c.cc.Invoke(ctx, GameCronService_ProcessLevelEventOutboxBatch_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GameCronServiceServer is the server API for GameCronService service.
// All implementations must embed UnimplementedGameCronServiceServer
// for forward compatibility.
//
// GameCronService 只给 cron-service 触发 game-service 拥有的补偿批处理。
type GameCronServiceServer interface {
	ProcessLevelEventOutboxBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error)
	mustEmbedUnimplementedGameCronServiceServer()
}

// UnimplementedGameCronServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedGameCronServiceServer struct{}

func (UnimplementedGameCronServiceServer) ProcessLevelEventOutboxBatch(context.Context, *CronBatchRequest) (*CronBatchResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ProcessLevelEventOutboxBatch not implemented")
}
func (UnimplementedGameCronServiceServer) mustEmbedUnimplementedGameCronServiceServer() {}
func (UnimplementedGameCronServiceServer) testEmbeddedByValue()                         {}

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

func RegisterGameCronServiceServer(s grpc.ServiceRegistrar, srv GameCronServiceServer) {
	// If the following call panics, it indicates UnimplementedGameCronServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&GameCronService_ServiceDesc, srv)
}

func _GameCronService_ProcessLevelEventOutboxBatch_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CronBatchRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameCronServiceServer).ProcessLevelEventOutboxBatch(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameCronService_ProcessLevelEventOutboxBatch_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameCronServiceServer).ProcessLevelEventOutboxBatch(ctx, req.(*CronBatchRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GameCronService_ServiceDesc is the grpc.ServiceDesc for GameCronService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GameCronService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.game.v1.GameCronService",
	HandlerType: (*GameCronServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ProcessLevelEventOutboxBatch",
			Handler:    _GameCronService_ProcessLevelEventOutboxBatch_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/game/v1/game.proto",
}

const (
	GameAdminService_ListPlatforms_FullMethodName               = "/hyapp.game.v1.GameAdminService/ListPlatforms"
	GameAdminService_UpsertPlatform_FullMethodName              = "/hyapp.game.v1.GameAdminService/UpsertPlatform"
	GameAdminService_ListCatalog_FullMethodName                 = "/hyapp.game.v1.GameAdminService/ListCatalog"
	GameAdminService_UpsertCatalog_FullMethodName               = "/hyapp.game.v1.GameAdminService/UpsertCatalog"
	GameAdminService_SetGameStatus_FullMethodName               = "/hyapp.game.v1.GameAdminService/SetGameStatus"
	GameAdminService_DeleteCatalog_FullMethodName               = "/hyapp.game.v1.GameAdminService/DeleteCatalog"
	GameAdminService_SetGameWhitelistEnabled_FullMethodName     = "/hyapp.game.v1.GameAdminService/SetGameWhitelistEnabled"
	GameAdminService_ListGameWhitelistUsers_FullMethodName      = "/hyapp.game.v1.GameAdminService/ListGameWhitelistUsers"
	GameAdminService_AddGameWhitelistUser_FullMethodName        = "/hyapp.game.v1.GameAdminService/AddGameWhitelistUser"
	GameAdminService_DeleteGameWhitelistUser_FullMethodName     = "/hyapp.game.v1.GameAdminService/DeleteGameWhitelistUser"
	GameAdminService_ListSelfGames_FullMethodName               = "/hyapp.game.v1.GameAdminService/ListSelfGames"
	GameAdminService_UpdateDiceConfig_FullMethodName            = "/hyapp.game.v1.GameAdminService/UpdateDiceConfig"
	GameAdminService_GetSelfGameNewUserPolicy_FullMethodName    = "/hyapp.game.v1.GameAdminService/GetSelfGameNewUserPolicy"
	GameAdminService_UpdateSelfGameNewUserPolicy_FullMethodName = "/hyapp.game.v1.GameAdminService/UpdateSelfGameNewUserPolicy"
	GameAdminService_ListSelfGameStakePools_FullMethodName      = "/hyapp.game.v1.GameAdminService/ListSelfGameStakePools"
	GameAdminService_UpdateSelfGameStakePool_FullMethodName     = "/hyapp.game.v1.GameAdminService/UpdateSelfGameStakePool"
	GameAdminService_AdjustSelfGameStakePool_FullMethodName     = "/hyapp.game.v1.GameAdminService/AdjustSelfGameStakePool"
	GameAdminService_ListDiceRobots_FullMethodName              = "/hyapp.game.v1.GameAdminService/ListDiceRobots"
	GameAdminService_RegisterDiceRobots_FullMethodName          = "/hyapp.game.v1.GameAdminService/RegisterDiceRobots"
	GameAdminService_SetDiceRobotStatus_FullMethodName          = "/hyapp.game.v1.GameAdminService/SetDiceRobotStatus"
	GameAdminService_DeleteDiceRobot_FullMethodName             = "/hyapp.game.v1.GameAdminService/DeleteDiceRobot"
	GameAdminService_GetRoomRPSConfig_FullMethodName            = "/hyapp.game.v1.GameAdminService/GetRoomRPSConfig"
	GameAdminService_UpdateRoomRPSConfig_FullMethodName         = "/hyapp.game.v1.GameAdminService/UpdateRoomRPSConfig"
	GameAdminService_ListRoomRPSChallenges_FullMethodName       = "/hyapp.game.v1.GameAdminService/ListRoomRPSChallenges"
	GameAdminService_GetRoomRPSChallenge_FullMethodName         = "/hyapp.game.v1.GameAdminService/GetRoomRPSChallenge"
	GameAdminService_RetryRoomRPSSettlement_FullMethodName      = "/hyapp.game.v1.GameAdminService/RetryRoomRPSSettlement"
	GameAdminService_ExpireRoomRPSChallenge_FullMethodName      = "/hyapp.game.v1.GameAdminService/ExpireRoomRPSChallenge"
)

// GameAdminServiceClient is the client API for GameAdminService 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 GameAdminServiceClient interface {
	ListPlatforms(ctx context.Context, in *ListPlatformsRequest, opts ...grpc.CallOption) (*ListPlatformsResponse, error)
	UpsertPlatform(ctx context.Context, in *UpsertPlatformRequest, opts ...grpc.CallOption) (*PlatformResponse, error)
	ListCatalog(ctx context.Context, in *ListCatalogRequest, opts ...grpc.CallOption) (*ListCatalogResponse, error)
	UpsertCatalog(ctx context.Context, in *UpsertCatalogRequest, opts ...grpc.CallOption) (*CatalogResponse, error)
	SetGameStatus(ctx context.Context, in *SetGameStatusRequest, opts ...grpc.CallOption) (*CatalogResponse, error)
	DeleteCatalog(ctx context.Context, in *DeleteCatalogRequest, opts ...grpc.CallOption) (*DeleteCatalogResponse, error)
	SetGameWhitelistEnabled(ctx context.Context, in *SetGameWhitelistEnabledRequest, opts ...grpc.CallOption) (*CatalogResponse, error)
	ListGameWhitelistUsers(ctx context.Context, in *ListGameWhitelistUsersRequest, opts ...grpc.CallOption) (*ListGameWhitelistUsersResponse, error)
	AddGameWhitelistUser(ctx context.Context, in *AddGameWhitelistUserRequest, opts ...grpc.CallOption) (*GameWhitelistUserResponse, error)
	DeleteGameWhitelistUser(ctx context.Context, in *DeleteGameWhitelistUserRequest, opts ...grpc.CallOption) (*DeleteGameWhitelistUserResponse, error)
	ListSelfGames(ctx context.Context, in *ListSelfGamesRequest, opts ...grpc.CallOption) (*ListSelfGamesResponse, error)
	UpdateDiceConfig(ctx context.Context, in *UpdateDiceConfigRequest, opts ...grpc.CallOption) (*DiceConfigResponse, error)
	GetSelfGameNewUserPolicy(ctx context.Context, in *GetSelfGameNewUserPolicyRequest, opts ...grpc.CallOption) (*SelfGameNewUserPolicyResponse, error)
	UpdateSelfGameNewUserPolicy(ctx context.Context, in *UpdateSelfGameNewUserPolicyRequest, opts ...grpc.CallOption) (*SelfGameNewUserPolicyResponse, error)
	ListSelfGameStakePools(ctx context.Context, in *ListSelfGameStakePoolsRequest, opts ...grpc.CallOption) (*ListSelfGameStakePoolsResponse, error)
	UpdateSelfGameStakePool(ctx context.Context, in *UpdateSelfGameStakePoolRequest, opts ...grpc.CallOption) (*SelfGameStakePoolResponse, error)
	AdjustSelfGameStakePool(ctx context.Context, in *AdjustSelfGameStakePoolRequest, opts ...grpc.CallOption) (*AdjustSelfGameStakePoolResponse, error)
	ListDiceRobots(ctx context.Context, in *ListDiceRobotsRequest, opts ...grpc.CallOption) (*ListDiceRobotsResponse, error)
	RegisterDiceRobots(ctx context.Context, in *RegisterDiceRobotsRequest, opts ...grpc.CallOption) (*RegisterDiceRobotsResponse, error)
	SetDiceRobotStatus(ctx context.Context, in *SetDiceRobotStatusRequest, opts ...grpc.CallOption) (*DiceRobotResponse, error)
	DeleteDiceRobot(ctx context.Context, in *DeleteDiceRobotRequest, opts ...grpc.CallOption) (*DeleteDiceRobotResponse, error)
	GetRoomRPSConfig(ctx context.Context, in *GetRoomRPSConfigRequest, opts ...grpc.CallOption) (*RoomRPSConfigResponse, error)
	UpdateRoomRPSConfig(ctx context.Context, in *UpdateRoomRPSConfigRequest, opts ...grpc.CallOption) (*RoomRPSConfigResponse, error)
	ListRoomRPSChallenges(ctx context.Context, in *ListRoomRPSChallengesRequest, opts ...grpc.CallOption) (*ListRoomRPSChallengesResponse, error)
	GetRoomRPSChallenge(ctx context.Context, in *GetRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error)
	RetryRoomRPSSettlement(ctx context.Context, in *RetryRoomRPSSettlementRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error)
	ExpireRoomRPSChallenge(ctx context.Context, in *ExpireRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error)
}

type gameAdminServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewGameAdminServiceClient(cc grpc.ClientConnInterface) GameAdminServiceClient {
	return &gameAdminServiceClient{cc}
}

func (c *gameAdminServiceClient) ListPlatforms(ctx context.Context, in *ListPlatformsRequest, opts ...grpc.CallOption) (*ListPlatformsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListPlatformsResponse)
	err := c.cc.Invoke(ctx, GameAdminService_ListPlatforms_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) UpsertPlatform(ctx context.Context, in *UpsertPlatformRequest, opts ...grpc.CallOption) (*PlatformResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PlatformResponse)
	err := c.cc.Invoke(ctx, GameAdminService_UpsertPlatform_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) ListCatalog(ctx context.Context, in *ListCatalogRequest, opts ...grpc.CallOption) (*ListCatalogResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListCatalogResponse)
	err := c.cc.Invoke(ctx, GameAdminService_ListCatalog_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) UpsertCatalog(ctx context.Context, in *UpsertCatalogRequest, opts ...grpc.CallOption) (*CatalogResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CatalogResponse)
	err := c.cc.Invoke(ctx, GameAdminService_UpsertCatalog_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) SetGameStatus(ctx context.Context, in *SetGameStatusRequest, opts ...grpc.CallOption) (*CatalogResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CatalogResponse)
	err := c.cc.Invoke(ctx, GameAdminService_SetGameStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) DeleteCatalog(ctx context.Context, in *DeleteCatalogRequest, opts ...grpc.CallOption) (*DeleteCatalogResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteCatalogResponse)
	err := c.cc.Invoke(ctx, GameAdminService_DeleteCatalog_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) SetGameWhitelistEnabled(ctx context.Context, in *SetGameWhitelistEnabledRequest, opts ...grpc.CallOption) (*CatalogResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CatalogResponse)
	err := c.cc.Invoke(ctx, GameAdminService_SetGameWhitelistEnabled_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) ListGameWhitelistUsers(ctx context.Context, in *ListGameWhitelistUsersRequest, opts ...grpc.CallOption) (*ListGameWhitelistUsersResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListGameWhitelistUsersResponse)
	err := c.cc.Invoke(ctx, GameAdminService_ListGameWhitelistUsers_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) AddGameWhitelistUser(ctx context.Context, in *AddGameWhitelistUserRequest, opts ...grpc.CallOption) (*GameWhitelistUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GameWhitelistUserResponse)
	err := c.cc.Invoke(ctx, GameAdminService_AddGameWhitelistUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) DeleteGameWhitelistUser(ctx context.Context, in *DeleteGameWhitelistUserRequest, opts ...grpc.CallOption) (*DeleteGameWhitelistUserResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteGameWhitelistUserResponse)
	err := c.cc.Invoke(ctx, GameAdminService_DeleteGameWhitelistUser_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) ListSelfGames(ctx context.Context, in *ListSelfGamesRequest, opts ...grpc.CallOption) (*ListSelfGamesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSelfGamesResponse)
	err := c.cc.Invoke(ctx, GameAdminService_ListSelfGames_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) UpdateDiceConfig(ctx context.Context, in *UpdateDiceConfigRequest, opts ...grpc.CallOption) (*DiceConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceConfigResponse)
	err := c.cc.Invoke(ctx, GameAdminService_UpdateDiceConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) GetSelfGameNewUserPolicy(ctx context.Context, in *GetSelfGameNewUserPolicyRequest, opts ...grpc.CallOption) (*SelfGameNewUserPolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SelfGameNewUserPolicyResponse)
	err := c.cc.Invoke(ctx, GameAdminService_GetSelfGameNewUserPolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) UpdateSelfGameNewUserPolicy(ctx context.Context, in *UpdateSelfGameNewUserPolicyRequest, opts ...grpc.CallOption) (*SelfGameNewUserPolicyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SelfGameNewUserPolicyResponse)
	err := c.cc.Invoke(ctx, GameAdminService_UpdateSelfGameNewUserPolicy_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) ListSelfGameStakePools(ctx context.Context, in *ListSelfGameStakePoolsRequest, opts ...grpc.CallOption) (*ListSelfGameStakePoolsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSelfGameStakePoolsResponse)
	err := c.cc.Invoke(ctx, GameAdminService_ListSelfGameStakePools_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) UpdateSelfGameStakePool(ctx context.Context, in *UpdateSelfGameStakePoolRequest, opts ...grpc.CallOption) (*SelfGameStakePoolResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SelfGameStakePoolResponse)
	err := c.cc.Invoke(ctx, GameAdminService_UpdateSelfGameStakePool_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) AdjustSelfGameStakePool(ctx context.Context, in *AdjustSelfGameStakePoolRequest, opts ...grpc.CallOption) (*AdjustSelfGameStakePoolResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(AdjustSelfGameStakePoolResponse)
	err := c.cc.Invoke(ctx, GameAdminService_AdjustSelfGameStakePool_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) ListDiceRobots(ctx context.Context, in *ListDiceRobotsRequest, opts ...grpc.CallOption) (*ListDiceRobotsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListDiceRobotsResponse)
	err := c.cc.Invoke(ctx, GameAdminService_ListDiceRobots_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) RegisterDiceRobots(ctx context.Context, in *RegisterDiceRobotsRequest, opts ...grpc.CallOption) (*RegisterDiceRobotsResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RegisterDiceRobotsResponse)
	err := c.cc.Invoke(ctx, GameAdminService_RegisterDiceRobots_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) SetDiceRobotStatus(ctx context.Context, in *SetDiceRobotStatusRequest, opts ...grpc.CallOption) (*DiceRobotResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DiceRobotResponse)
	err := c.cc.Invoke(ctx, GameAdminService_SetDiceRobotStatus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) DeleteDiceRobot(ctx context.Context, in *DeleteDiceRobotRequest, opts ...grpc.CallOption) (*DeleteDiceRobotResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DeleteDiceRobotResponse)
	err := c.cc.Invoke(ctx, GameAdminService_DeleteDiceRobot_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) GetRoomRPSConfig(ctx context.Context, in *GetRoomRPSConfigRequest, opts ...grpc.CallOption) (*RoomRPSConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSConfigResponse)
	err := c.cc.Invoke(ctx, GameAdminService_GetRoomRPSConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) UpdateRoomRPSConfig(ctx context.Context, in *UpdateRoomRPSConfigRequest, opts ...grpc.CallOption) (*RoomRPSConfigResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSConfigResponse)
	err := c.cc.Invoke(ctx, GameAdminService_UpdateRoomRPSConfig_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) ListRoomRPSChallenges(ctx context.Context, in *ListRoomRPSChallengesRequest, opts ...grpc.CallOption) (*ListRoomRPSChallengesResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListRoomRPSChallengesResponse)
	err := c.cc.Invoke(ctx, GameAdminService_ListRoomRPSChallenges_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) GetRoomRPSChallenge(ctx context.Context, in *GetRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSChallengeResponse)
	err := c.cc.Invoke(ctx, GameAdminService_GetRoomRPSChallenge_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) RetryRoomRPSSettlement(ctx context.Context, in *RetryRoomRPSSettlementRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSChallengeResponse)
	err := c.cc.Invoke(ctx, GameAdminService_RetryRoomRPSSettlement_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *gameAdminServiceClient) ExpireRoomRPSChallenge(ctx context.Context, in *ExpireRoomRPSChallengeRequest, opts ...grpc.CallOption) (*RoomRPSChallengeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RoomRPSChallengeResponse)
	err := c.cc.Invoke(ctx, GameAdminService_ExpireRoomRPSChallenge_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GameAdminServiceServer is the server API for GameAdminService service.
// All implementations must embed UnimplementedGameAdminServiceServer
// for forward compatibility.
type GameAdminServiceServer interface {
	ListPlatforms(context.Context, *ListPlatformsRequest) (*ListPlatformsResponse, error)
	UpsertPlatform(context.Context, *UpsertPlatformRequest) (*PlatformResponse, error)
	ListCatalog(context.Context, *ListCatalogRequest) (*ListCatalogResponse, error)
	UpsertCatalog(context.Context, *UpsertCatalogRequest) (*CatalogResponse, error)
	SetGameStatus(context.Context, *SetGameStatusRequest) (*CatalogResponse, error)
	DeleteCatalog(context.Context, *DeleteCatalogRequest) (*DeleteCatalogResponse, error)
	SetGameWhitelistEnabled(context.Context, *SetGameWhitelistEnabledRequest) (*CatalogResponse, error)
	ListGameWhitelistUsers(context.Context, *ListGameWhitelistUsersRequest) (*ListGameWhitelistUsersResponse, error)
	AddGameWhitelistUser(context.Context, *AddGameWhitelistUserRequest) (*GameWhitelistUserResponse, error)
	DeleteGameWhitelistUser(context.Context, *DeleteGameWhitelistUserRequest) (*DeleteGameWhitelistUserResponse, error)
	ListSelfGames(context.Context, *ListSelfGamesRequest) (*ListSelfGamesResponse, error)
	UpdateDiceConfig(context.Context, *UpdateDiceConfigRequest) (*DiceConfigResponse, error)
	GetSelfGameNewUserPolicy(context.Context, *GetSelfGameNewUserPolicyRequest) (*SelfGameNewUserPolicyResponse, error)
	UpdateSelfGameNewUserPolicy(context.Context, *UpdateSelfGameNewUserPolicyRequest) (*SelfGameNewUserPolicyResponse, error)
	ListSelfGameStakePools(context.Context, *ListSelfGameStakePoolsRequest) (*ListSelfGameStakePoolsResponse, error)
	UpdateSelfGameStakePool(context.Context, *UpdateSelfGameStakePoolRequest) (*SelfGameStakePoolResponse, error)
	AdjustSelfGameStakePool(context.Context, *AdjustSelfGameStakePoolRequest) (*AdjustSelfGameStakePoolResponse, error)
	ListDiceRobots(context.Context, *ListDiceRobotsRequest) (*ListDiceRobotsResponse, error)
	RegisterDiceRobots(context.Context, *RegisterDiceRobotsRequest) (*RegisterDiceRobotsResponse, error)
	SetDiceRobotStatus(context.Context, *SetDiceRobotStatusRequest) (*DiceRobotResponse, error)
	DeleteDiceRobot(context.Context, *DeleteDiceRobotRequest) (*DeleteDiceRobotResponse, error)
	GetRoomRPSConfig(context.Context, *GetRoomRPSConfigRequest) (*RoomRPSConfigResponse, error)
	UpdateRoomRPSConfig(context.Context, *UpdateRoomRPSConfigRequest) (*RoomRPSConfigResponse, error)
	ListRoomRPSChallenges(context.Context, *ListRoomRPSChallengesRequest) (*ListRoomRPSChallengesResponse, error)
	GetRoomRPSChallenge(context.Context, *GetRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error)
	RetryRoomRPSSettlement(context.Context, *RetryRoomRPSSettlementRequest) (*RoomRPSChallengeResponse, error)
	ExpireRoomRPSChallenge(context.Context, *ExpireRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error)
	mustEmbedUnimplementedGameAdminServiceServer()
}

// UnimplementedGameAdminServiceServer must be embedded to have
// forward compatible implementations.
//
// NOTE: this should be embedded by value instead of pointer to avoid a nil
// pointer dereference when methods are called.
type UnimplementedGameAdminServiceServer struct{}

func (UnimplementedGameAdminServiceServer) ListPlatforms(context.Context, *ListPlatformsRequest) (*ListPlatformsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListPlatforms not implemented")
}
func (UnimplementedGameAdminServiceServer) UpsertPlatform(context.Context, *UpsertPlatformRequest) (*PlatformResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpsertPlatform not implemented")
}
func (UnimplementedGameAdminServiceServer) ListCatalog(context.Context, *ListCatalogRequest) (*ListCatalogResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListCatalog not implemented")
}
func (UnimplementedGameAdminServiceServer) UpsertCatalog(context.Context, *UpsertCatalogRequest) (*CatalogResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpsertCatalog not implemented")
}
func (UnimplementedGameAdminServiceServer) SetGameStatus(context.Context, *SetGameStatusRequest) (*CatalogResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SetGameStatus not implemented")
}
func (UnimplementedGameAdminServiceServer) DeleteCatalog(context.Context, *DeleteCatalogRequest) (*DeleteCatalogResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteCatalog not implemented")
}
func (UnimplementedGameAdminServiceServer) SetGameWhitelistEnabled(context.Context, *SetGameWhitelistEnabledRequest) (*CatalogResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SetGameWhitelistEnabled not implemented")
}
func (UnimplementedGameAdminServiceServer) ListGameWhitelistUsers(context.Context, *ListGameWhitelistUsersRequest) (*ListGameWhitelistUsersResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListGameWhitelistUsers not implemented")
}
func (UnimplementedGameAdminServiceServer) AddGameWhitelistUser(context.Context, *AddGameWhitelistUserRequest) (*GameWhitelistUserResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method AddGameWhitelistUser not implemented")
}
func (UnimplementedGameAdminServiceServer) DeleteGameWhitelistUser(context.Context, *DeleteGameWhitelistUserRequest) (*DeleteGameWhitelistUserResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteGameWhitelistUser not implemented")
}
func (UnimplementedGameAdminServiceServer) ListSelfGames(context.Context, *ListSelfGamesRequest) (*ListSelfGamesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListSelfGames not implemented")
}
func (UnimplementedGameAdminServiceServer) UpdateDiceConfig(context.Context, *UpdateDiceConfigRequest) (*DiceConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateDiceConfig not implemented")
}
func (UnimplementedGameAdminServiceServer) GetSelfGameNewUserPolicy(context.Context, *GetSelfGameNewUserPolicyRequest) (*SelfGameNewUserPolicyResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetSelfGameNewUserPolicy not implemented")
}
func (UnimplementedGameAdminServiceServer) UpdateSelfGameNewUserPolicy(context.Context, *UpdateSelfGameNewUserPolicyRequest) (*SelfGameNewUserPolicyResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateSelfGameNewUserPolicy not implemented")
}
func (UnimplementedGameAdminServiceServer) ListSelfGameStakePools(context.Context, *ListSelfGameStakePoolsRequest) (*ListSelfGameStakePoolsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListSelfGameStakePools not implemented")
}
func (UnimplementedGameAdminServiceServer) UpdateSelfGameStakePool(context.Context, *UpdateSelfGameStakePoolRequest) (*SelfGameStakePoolResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateSelfGameStakePool not implemented")
}
func (UnimplementedGameAdminServiceServer) AdjustSelfGameStakePool(context.Context, *AdjustSelfGameStakePoolRequest) (*AdjustSelfGameStakePoolResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method AdjustSelfGameStakePool not implemented")
}
func (UnimplementedGameAdminServiceServer) ListDiceRobots(context.Context, *ListDiceRobotsRequest) (*ListDiceRobotsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListDiceRobots not implemented")
}
func (UnimplementedGameAdminServiceServer) RegisterDiceRobots(context.Context, *RegisterDiceRobotsRequest) (*RegisterDiceRobotsResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method RegisterDiceRobots not implemented")
}
func (UnimplementedGameAdminServiceServer) SetDiceRobotStatus(context.Context, *SetDiceRobotStatusRequest) (*DiceRobotResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method SetDiceRobotStatus not implemented")
}
func (UnimplementedGameAdminServiceServer) DeleteDiceRobot(context.Context, *DeleteDiceRobotRequest) (*DeleteDiceRobotResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method DeleteDiceRobot not implemented")
}
func (UnimplementedGameAdminServiceServer) GetRoomRPSConfig(context.Context, *GetRoomRPSConfigRequest) (*RoomRPSConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRoomRPSConfig not implemented")
}
func (UnimplementedGameAdminServiceServer) UpdateRoomRPSConfig(context.Context, *UpdateRoomRPSConfigRequest) (*RoomRPSConfigResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method UpdateRoomRPSConfig not implemented")
}
func (UnimplementedGameAdminServiceServer) ListRoomRPSChallenges(context.Context, *ListRoomRPSChallengesRequest) (*ListRoomRPSChallengesResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ListRoomRPSChallenges not implemented")
}
func (UnimplementedGameAdminServiceServer) GetRoomRPSChallenge(context.Context, *GetRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method GetRoomRPSChallenge not implemented")
}
func (UnimplementedGameAdminServiceServer) RetryRoomRPSSettlement(context.Context, *RetryRoomRPSSettlementRequest) (*RoomRPSChallengeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method RetryRoomRPSSettlement not implemented")
}
func (UnimplementedGameAdminServiceServer) ExpireRoomRPSChallenge(context.Context, *ExpireRoomRPSChallengeRequest) (*RoomRPSChallengeResponse, error) {
	return nil, status.Error(codes.Unimplemented, "method ExpireRoomRPSChallenge not implemented")
}
func (UnimplementedGameAdminServiceServer) mustEmbedUnimplementedGameAdminServiceServer() {}
func (UnimplementedGameAdminServiceServer) testEmbeddedByValue()                          {}

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

func RegisterGameAdminServiceServer(s grpc.ServiceRegistrar, srv GameAdminServiceServer) {
	// If the following call panics, it indicates UnimplementedGameAdminServiceServer was
	// embedded by pointer and is nil.  This will cause panics if an
	// unimplemented method is ever invoked, so we test this at initialization
	// time to prevent it from happening at runtime later due to I/O.
	if t, ok := srv.(interface{ testEmbeddedByValue() }); ok {
		t.testEmbeddedByValue()
	}
	s.RegisterService(&GameAdminService_ServiceDesc, srv)
}

func _GameAdminService_ListPlatforms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPlatformsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).ListPlatforms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_ListPlatforms_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).ListPlatforms(ctx, req.(*ListPlatformsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_UpsertPlatform_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertPlatformRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).UpsertPlatform(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_UpsertPlatform_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).UpsertPlatform(ctx, req.(*UpsertPlatformRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_ListCatalog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCatalogRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).ListCatalog(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_ListCatalog_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).ListCatalog(ctx, req.(*ListCatalogRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_UpsertCatalog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpsertCatalogRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).UpsertCatalog(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_UpsertCatalog_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).UpsertCatalog(ctx, req.(*UpsertCatalogRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_SetGameStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetGameStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).SetGameStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_SetGameStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).SetGameStatus(ctx, req.(*SetGameStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_DeleteCatalog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteCatalogRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).DeleteCatalog(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_DeleteCatalog_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).DeleteCatalog(ctx, req.(*DeleteCatalogRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_SetGameWhitelistEnabled_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetGameWhitelistEnabledRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).SetGameWhitelistEnabled(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_SetGameWhitelistEnabled_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).SetGameWhitelistEnabled(ctx, req.(*SetGameWhitelistEnabledRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_ListGameWhitelistUsers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListGameWhitelistUsersRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).ListGameWhitelistUsers(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_ListGameWhitelistUsers_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).ListGameWhitelistUsers(ctx, req.(*ListGameWhitelistUsersRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_AddGameWhitelistUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddGameWhitelistUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).AddGameWhitelistUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_AddGameWhitelistUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).AddGameWhitelistUser(ctx, req.(*AddGameWhitelistUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_DeleteGameWhitelistUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteGameWhitelistUserRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).DeleteGameWhitelistUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_DeleteGameWhitelistUser_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).DeleteGameWhitelistUser(ctx, req.(*DeleteGameWhitelistUserRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_ListSelfGames_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSelfGamesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).ListSelfGames(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_ListSelfGames_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).ListSelfGames(ctx, req.(*ListSelfGamesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_UpdateDiceConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateDiceConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).UpdateDiceConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_UpdateDiceConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).UpdateDiceConfig(ctx, req.(*UpdateDiceConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_GetSelfGameNewUserPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSelfGameNewUserPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).GetSelfGameNewUserPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_GetSelfGameNewUserPolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).GetSelfGameNewUserPolicy(ctx, req.(*GetSelfGameNewUserPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_UpdateSelfGameNewUserPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSelfGameNewUserPolicyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).UpdateSelfGameNewUserPolicy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_UpdateSelfGameNewUserPolicy_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).UpdateSelfGameNewUserPolicy(ctx, req.(*UpdateSelfGameNewUserPolicyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_ListSelfGameStakePools_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSelfGameStakePoolsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).ListSelfGameStakePools(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_ListSelfGameStakePools_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).ListSelfGameStakePools(ctx, req.(*ListSelfGameStakePoolsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_UpdateSelfGameStakePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSelfGameStakePoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).UpdateSelfGameStakePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_UpdateSelfGameStakePool_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).UpdateSelfGameStakePool(ctx, req.(*UpdateSelfGameStakePoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_AdjustSelfGameStakePool_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AdjustSelfGameStakePoolRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).AdjustSelfGameStakePool(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_AdjustSelfGameStakePool_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).AdjustSelfGameStakePool(ctx, req.(*AdjustSelfGameStakePoolRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_ListDiceRobots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDiceRobotsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).ListDiceRobots(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_ListDiceRobots_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).ListDiceRobots(ctx, req.(*ListDiceRobotsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_RegisterDiceRobots_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterDiceRobotsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).RegisterDiceRobots(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_RegisterDiceRobots_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).RegisterDiceRobots(ctx, req.(*RegisterDiceRobotsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_SetDiceRobotStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetDiceRobotStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).SetDiceRobotStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_SetDiceRobotStatus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).SetDiceRobotStatus(ctx, req.(*SetDiceRobotStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_DeleteDiceRobot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteDiceRobotRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).DeleteDiceRobot(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_DeleteDiceRobot_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).DeleteDiceRobot(ctx, req.(*DeleteDiceRobotRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_GetRoomRPSConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRoomRPSConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).GetRoomRPSConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_GetRoomRPSConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).GetRoomRPSConfig(ctx, req.(*GetRoomRPSConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_UpdateRoomRPSConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateRoomRPSConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).UpdateRoomRPSConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_UpdateRoomRPSConfig_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).UpdateRoomRPSConfig(ctx, req.(*UpdateRoomRPSConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_ListRoomRPSChallenges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRoomRPSChallengesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).ListRoomRPSChallenges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_ListRoomRPSChallenges_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).ListRoomRPSChallenges(ctx, req.(*ListRoomRPSChallengesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_GetRoomRPSChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRoomRPSChallengeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).GetRoomRPSChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_GetRoomRPSChallenge_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).GetRoomRPSChallenge(ctx, req.(*GetRoomRPSChallengeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_RetryRoomRPSSettlement_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RetryRoomRPSSettlementRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).RetryRoomRPSSettlement(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_RetryRoomRPSSettlement_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).RetryRoomRPSSettlement(ctx, req.(*RetryRoomRPSSettlementRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _GameAdminService_ExpireRoomRPSChallenge_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExpireRoomRPSChallengeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GameAdminServiceServer).ExpireRoomRPSChallenge(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: GameAdminService_ExpireRoomRPSChallenge_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GameAdminServiceServer).ExpireRoomRPSChallenge(ctx, req.(*ExpireRoomRPSChallengeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// GameAdminService_ServiceDesc is the grpc.ServiceDesc for GameAdminService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var GameAdminService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "hyapp.game.v1.GameAdminService",
	HandlerType: (*GameAdminServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListPlatforms",
			Handler:    _GameAdminService_ListPlatforms_Handler,
		},
		{
			MethodName: "UpsertPlatform",
			Handler:    _GameAdminService_UpsertPlatform_Handler,
		},
		{
			MethodName: "ListCatalog",
			Handler:    _GameAdminService_ListCatalog_Handler,
		},
		{
			MethodName: "UpsertCatalog",
			Handler:    _GameAdminService_UpsertCatalog_Handler,
		},
		{
			MethodName: "SetGameStatus",
			Handler:    _GameAdminService_SetGameStatus_Handler,
		},
		{
			MethodName: "DeleteCatalog",
			Handler:    _GameAdminService_DeleteCatalog_Handler,
		},
		{
			MethodName: "SetGameWhitelistEnabled",
			Handler:    _GameAdminService_SetGameWhitelistEnabled_Handler,
		},
		{
			MethodName: "ListGameWhitelistUsers",
			Handler:    _GameAdminService_ListGameWhitelistUsers_Handler,
		},
		{
			MethodName: "AddGameWhitelistUser",
			Handler:    _GameAdminService_AddGameWhitelistUser_Handler,
		},
		{
			MethodName: "DeleteGameWhitelistUser",
			Handler:    _GameAdminService_DeleteGameWhitelistUser_Handler,
		},
		{
			MethodName: "ListSelfGames",
			Handler:    _GameAdminService_ListSelfGames_Handler,
		},
		{
			MethodName: "UpdateDiceConfig",
			Handler:    _GameAdminService_UpdateDiceConfig_Handler,
		},
		{
			MethodName: "GetSelfGameNewUserPolicy",
			Handler:    _GameAdminService_GetSelfGameNewUserPolicy_Handler,
		},
		{
			MethodName: "UpdateSelfGameNewUserPolicy",
			Handler:    _GameAdminService_UpdateSelfGameNewUserPolicy_Handler,
		},
		{
			MethodName: "ListSelfGameStakePools",
			Handler:    _GameAdminService_ListSelfGameStakePools_Handler,
		},
		{
			MethodName: "UpdateSelfGameStakePool",
			Handler:    _GameAdminService_UpdateSelfGameStakePool_Handler,
		},
		{
			MethodName: "AdjustSelfGameStakePool",
			Handler:    _GameAdminService_AdjustSelfGameStakePool_Handler,
		},
		{
			MethodName: "ListDiceRobots",
			Handler:    _GameAdminService_ListDiceRobots_Handler,
		},
		{
			MethodName: "RegisterDiceRobots",
			Handler:    _GameAdminService_RegisterDiceRobots_Handler,
		},
		{
			MethodName: "SetDiceRobotStatus",
			Handler:    _GameAdminService_SetDiceRobotStatus_Handler,
		},
		{
			MethodName: "DeleteDiceRobot",
			Handler:    _GameAdminService_DeleteDiceRobot_Handler,
		},
		{
			MethodName: "GetRoomRPSConfig",
			Handler:    _GameAdminService_GetRoomRPSConfig_Handler,
		},
		{
			MethodName: "UpdateRoomRPSConfig",
			Handler:    _GameAdminService_UpdateRoomRPSConfig_Handler,
		},
		{
			MethodName: "ListRoomRPSChallenges",
			Handler:    _GameAdminService_ListRoomRPSChallenges_Handler,
		},
		{
			MethodName: "GetRoomRPSChallenge",
			Handler:    _GameAdminService_GetRoomRPSChallenge_Handler,
		},
		{
			MethodName: "RetryRoomRPSSettlement",
			Handler:    _GameAdminService_RetryRoomRPSSettlement_Handler,
		},
		{
			MethodName: "ExpireRoomRPSChallenge",
			Handler:    _GameAdminService_ExpireRoomRPSChallenge_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "proto/game/v1/game.proto",
}
