// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.5.1
// - protoc             (unknown)
// source: autokitteh/user_code/v1/handler_svc.proto

package user_codev1

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 (
	HandlerService_Activity_FullMethodName          = "/autokitteh.user_code.v1.HandlerService/Activity"
	HandlerService_ExecuteReply_FullMethodName      = "/autokitteh.user_code.v1.HandlerService/ExecuteReply"
	HandlerService_Done_FullMethodName              = "/autokitteh.user_code.v1.HandlerService/Done"
	HandlerService_Log_FullMethodName               = "/autokitteh.user_code.v1.HandlerService/Log"
	HandlerService_Print_FullMethodName             = "/autokitteh.user_code.v1.HandlerService/Print"
	HandlerService_Sleep_FullMethodName             = "/autokitteh.user_code.v1.HandlerService/Sleep"
	HandlerService_Subscribe_FullMethodName         = "/autokitteh.user_code.v1.HandlerService/Subscribe"
	HandlerService_NextEvent_FullMethodName         = "/autokitteh.user_code.v1.HandlerService/NextEvent"
	HandlerService_Unsubscribe_FullMethodName       = "/autokitteh.user_code.v1.HandlerService/Unsubscribe"
	HandlerService_StartSession_FullMethodName      = "/autokitteh.user_code.v1.HandlerService/StartSession"
	HandlerService_Signal_FullMethodName            = "/autokitteh.user_code.v1.HandlerService/Signal"
	HandlerService_NextSignal_FullMethodName        = "/autokitteh.user_code.v1.HandlerService/NextSignal"
	HandlerService_StoreList_FullMethodName         = "/autokitteh.user_code.v1.HandlerService/StoreList"
	HandlerService_StoreMutate_FullMethodName       = "/autokitteh.user_code.v1.HandlerService/StoreMutate"
	HandlerService_Outcome_FullMethodName           = "/autokitteh.user_code.v1.HandlerService/Outcome"
	HandlerService_EncodeJWT_FullMethodName         = "/autokitteh.user_code.v1.HandlerService/EncodeJWT"
	HandlerService_RefreshOAuthToken_FullMethodName = "/autokitteh.user_code.v1.HandlerService/RefreshOAuthToken"
	HandlerService_Health_FullMethodName            = "/autokitteh.user_code.v1.HandlerService/Health"
	HandlerService_IsActiveRunner_FullMethodName    = "/autokitteh.user_code.v1.HandlerService/IsActiveRunner"
)

// HandlerServiceClient is the client API for HandlerService 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 HandlerServiceClient interface {
	// Runner starting activity
	Activity(ctx context.Context, in *ActivityRequest, opts ...grpc.CallOption) (*ActivityResponse, error)
	// Runner result from execute
	ExecuteReply(ctx context.Context, in *ExecuteReplyRequest, opts ...grpc.CallOption) (*ExecuteReplyResponse, error)
	// Runner done with activity
	Done(ctx context.Context, in *DoneRequest, opts ...grpc.CallOption) (*DoneResponse, error)
	// Session logs
	Log(ctx context.Context, in *LogRequest, opts ...grpc.CallOption) (*LogResponse, error)
	// Print to session log
	Print(ctx context.Context, in *PrintRequest, opts ...grpc.CallOption) (*PrintResponse, error)
	// ak functions
	Sleep(ctx context.Context, in *SleepRequest, opts ...grpc.CallOption) (*SleepResponse, error)
	Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (*SubscribeResponse, error)
	NextEvent(ctx context.Context, in *NextEventRequest, opts ...grpc.CallOption) (*NextEventResponse, error)
	Unsubscribe(ctx context.Context, in *UnsubscribeRequest, opts ...grpc.CallOption) (*UnsubscribeResponse, error)
	StartSession(ctx context.Context, in *StartSessionRequest, opts ...grpc.CallOption) (*StartSessionResponse, error)
	Signal(ctx context.Context, in *SignalRequest, opts ...grpc.CallOption) (*SignalResponse, error)
	NextSignal(ctx context.Context, in *NextSignalRequest, opts ...grpc.CallOption) (*NextSignalResponse, error)
	StoreList(ctx context.Context, in *StoreListRequest, opts ...grpc.CallOption) (*StoreListResponse, error)
	StoreMutate(ctx context.Context, in *StoreMutateRequest, opts ...grpc.CallOption) (*StoreMutateResponse, error)
	Outcome(ctx context.Context, in *OutcomeRequest, opts ...grpc.CallOption) (*OutcomeResponse, error)
	// Utility functions
	EncodeJWT(ctx context.Context, in *EncodeJWTRequest, opts ...grpc.CallOption) (*EncodeJWTResponse, error)
	RefreshOAuthToken(ctx context.Context, in *RefreshRequest, opts ...grpc.CallOption) (*RefreshResponse, error)
	Health(ctx context.Context, in *HandlerHealthRequest, opts ...grpc.CallOption) (*HandlerHealthResponse, error)
	IsActiveRunner(ctx context.Context, in *IsActiveRunnerRequest, opts ...grpc.CallOption) (*IsActiveRunnerResponse, error)
}

type handlerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewHandlerServiceClient(cc grpc.ClientConnInterface) HandlerServiceClient {
	return &handlerServiceClient{cc}
}

func (c *handlerServiceClient) Activity(ctx context.Context, in *ActivityRequest, opts ...grpc.CallOption) (*ActivityResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ActivityResponse)
	err := c.cc.Invoke(ctx, HandlerService_Activity_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) ExecuteReply(ctx context.Context, in *ExecuteReplyRequest, opts ...grpc.CallOption) (*ExecuteReplyResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ExecuteReplyResponse)
	err := c.cc.Invoke(ctx, HandlerService_ExecuteReply_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Done(ctx context.Context, in *DoneRequest, opts ...grpc.CallOption) (*DoneResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DoneResponse)
	err := c.cc.Invoke(ctx, HandlerService_Done_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Log(ctx context.Context, in *LogRequest, opts ...grpc.CallOption) (*LogResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(LogResponse)
	err := c.cc.Invoke(ctx, HandlerService_Log_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Print(ctx context.Context, in *PrintRequest, opts ...grpc.CallOption) (*PrintResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(PrintResponse)
	err := c.cc.Invoke(ctx, HandlerService_Print_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Sleep(ctx context.Context, in *SleepRequest, opts ...grpc.CallOption) (*SleepResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SleepResponse)
	err := c.cc.Invoke(ctx, HandlerService_Sleep_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Subscribe(ctx context.Context, in *SubscribeRequest, opts ...grpc.CallOption) (*SubscribeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SubscribeResponse)
	err := c.cc.Invoke(ctx, HandlerService_Subscribe_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) NextEvent(ctx context.Context, in *NextEventRequest, opts ...grpc.CallOption) (*NextEventResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NextEventResponse)
	err := c.cc.Invoke(ctx, HandlerService_NextEvent_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Unsubscribe(ctx context.Context, in *UnsubscribeRequest, opts ...grpc.CallOption) (*UnsubscribeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UnsubscribeResponse)
	err := c.cc.Invoke(ctx, HandlerService_Unsubscribe_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) StartSession(ctx context.Context, in *StartSessionRequest, opts ...grpc.CallOption) (*StartSessionResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StartSessionResponse)
	err := c.cc.Invoke(ctx, HandlerService_StartSession_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Signal(ctx context.Context, in *SignalRequest, opts ...grpc.CallOption) (*SignalResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(SignalResponse)
	err := c.cc.Invoke(ctx, HandlerService_Signal_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) NextSignal(ctx context.Context, in *NextSignalRequest, opts ...grpc.CallOption) (*NextSignalResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(NextSignalResponse)
	err := c.cc.Invoke(ctx, HandlerService_NextSignal_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) StoreList(ctx context.Context, in *StoreListRequest, opts ...grpc.CallOption) (*StoreListResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StoreListResponse)
	err := c.cc.Invoke(ctx, HandlerService_StoreList_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) StoreMutate(ctx context.Context, in *StoreMutateRequest, opts ...grpc.CallOption) (*StoreMutateResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StoreMutateResponse)
	err := c.cc.Invoke(ctx, HandlerService_StoreMutate_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Outcome(ctx context.Context, in *OutcomeRequest, opts ...grpc.CallOption) (*OutcomeResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(OutcomeResponse)
	err := c.cc.Invoke(ctx, HandlerService_Outcome_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) EncodeJWT(ctx context.Context, in *EncodeJWTRequest, opts ...grpc.CallOption) (*EncodeJWTResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EncodeJWTResponse)
	err := c.cc.Invoke(ctx, HandlerService_EncodeJWT_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) RefreshOAuthToken(ctx context.Context, in *RefreshRequest, opts ...grpc.CallOption) (*RefreshResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(RefreshResponse)
	err := c.cc.Invoke(ctx, HandlerService_RefreshOAuthToken_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) Health(ctx context.Context, in *HandlerHealthRequest, opts ...grpc.CallOption) (*HandlerHealthResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(HandlerHealthResponse)
	err := c.cc.Invoke(ctx, HandlerService_Health_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *handlerServiceClient) IsActiveRunner(ctx context.Context, in *IsActiveRunnerRequest, opts ...grpc.CallOption) (*IsActiveRunnerResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(IsActiveRunnerResponse)
	err := c.cc.Invoke(ctx, HandlerService_IsActiveRunner_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// HandlerServiceServer is the server API for HandlerService service.
// All implementations must embed UnimplementedHandlerServiceServer
// for forward compatibility.
type HandlerServiceServer interface {
	// Runner starting activity
	Activity(context.Context, *ActivityRequest) (*ActivityResponse, error)
	// Runner result from execute
	ExecuteReply(context.Context, *ExecuteReplyRequest) (*ExecuteReplyResponse, error)
	// Runner done with activity
	Done(context.Context, *DoneRequest) (*DoneResponse, error)
	// Session logs
	Log(context.Context, *LogRequest) (*LogResponse, error)
	// Print to session log
	Print(context.Context, *PrintRequest) (*PrintResponse, error)
	// ak functions
	Sleep(context.Context, *SleepRequest) (*SleepResponse, error)
	Subscribe(context.Context, *SubscribeRequest) (*SubscribeResponse, error)
	NextEvent(context.Context, *NextEventRequest) (*NextEventResponse, error)
	Unsubscribe(context.Context, *UnsubscribeRequest) (*UnsubscribeResponse, error)
	StartSession(context.Context, *StartSessionRequest) (*StartSessionResponse, error)
	Signal(context.Context, *SignalRequest) (*SignalResponse, error)
	NextSignal(context.Context, *NextSignalRequest) (*NextSignalResponse, error)
	StoreList(context.Context, *StoreListRequest) (*StoreListResponse, error)
	StoreMutate(context.Context, *StoreMutateRequest) (*StoreMutateResponse, error)
	Outcome(context.Context, *OutcomeRequest) (*OutcomeResponse, error)
	// Utility functions
	EncodeJWT(context.Context, *EncodeJWTRequest) (*EncodeJWTResponse, error)
	RefreshOAuthToken(context.Context, *RefreshRequest) (*RefreshResponse, error)
	Health(context.Context, *HandlerHealthRequest) (*HandlerHealthResponse, error)
	IsActiveRunner(context.Context, *IsActiveRunnerRequest) (*IsActiveRunnerResponse, error)
	mustEmbedUnimplementedHandlerServiceServer()
}

// UnimplementedHandlerServiceServer 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 UnimplementedHandlerServiceServer struct{}

func (UnimplementedHandlerServiceServer) Activity(context.Context, *ActivityRequest) (*ActivityResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Activity not implemented")
}
func (UnimplementedHandlerServiceServer) ExecuteReply(context.Context, *ExecuteReplyRequest) (*ExecuteReplyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExecuteReply not implemented")
}
func (UnimplementedHandlerServiceServer) Done(context.Context, *DoneRequest) (*DoneResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Done not implemented")
}
func (UnimplementedHandlerServiceServer) Log(context.Context, *LogRequest) (*LogResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Log not implemented")
}
func (UnimplementedHandlerServiceServer) Print(context.Context, *PrintRequest) (*PrintResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Print not implemented")
}
func (UnimplementedHandlerServiceServer) Sleep(context.Context, *SleepRequest) (*SleepResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Sleep not implemented")
}
func (UnimplementedHandlerServiceServer) Subscribe(context.Context, *SubscribeRequest) (*SubscribeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Subscribe not implemented")
}
func (UnimplementedHandlerServiceServer) NextEvent(context.Context, *NextEventRequest) (*NextEventResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NextEvent not implemented")
}
func (UnimplementedHandlerServiceServer) Unsubscribe(context.Context, *UnsubscribeRequest) (*UnsubscribeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Unsubscribe not implemented")
}
func (UnimplementedHandlerServiceServer) StartSession(context.Context, *StartSessionRequest) (*StartSessionResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartSession not implemented")
}
func (UnimplementedHandlerServiceServer) Signal(context.Context, *SignalRequest) (*SignalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Signal not implemented")
}
func (UnimplementedHandlerServiceServer) NextSignal(context.Context, *NextSignalRequest) (*NextSignalResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method NextSignal not implemented")
}
func (UnimplementedHandlerServiceServer) StoreList(context.Context, *StoreListRequest) (*StoreListResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StoreList not implemented")
}
func (UnimplementedHandlerServiceServer) StoreMutate(context.Context, *StoreMutateRequest) (*StoreMutateResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StoreMutate not implemented")
}
func (UnimplementedHandlerServiceServer) Outcome(context.Context, *OutcomeRequest) (*OutcomeResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Outcome not implemented")
}
func (UnimplementedHandlerServiceServer) EncodeJWT(context.Context, *EncodeJWTRequest) (*EncodeJWTResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EncodeJWT not implemented")
}
func (UnimplementedHandlerServiceServer) RefreshOAuthToken(context.Context, *RefreshRequest) (*RefreshResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RefreshOAuthToken not implemented")
}
func (UnimplementedHandlerServiceServer) Health(context.Context, *HandlerHealthRequest) (*HandlerHealthResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Health not implemented")
}
func (UnimplementedHandlerServiceServer) IsActiveRunner(context.Context, *IsActiveRunnerRequest) (*IsActiveRunnerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method IsActiveRunner not implemented")
}
func (UnimplementedHandlerServiceServer) mustEmbedUnimplementedHandlerServiceServer() {}
func (UnimplementedHandlerServiceServer) testEmbeddedByValue()                        {}

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

func RegisterHandlerServiceServer(s grpc.ServiceRegistrar, srv HandlerServiceServer) {
	// If the following call pancis, it indicates UnimplementedHandlerServiceServer 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(&HandlerService_ServiceDesc, srv)
}

func _HandlerService_Activity_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ActivityRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Activity(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Activity_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Activity(ctx, req.(*ActivityRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_ExecuteReply_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecuteReplyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).ExecuteReply(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_ExecuteReply_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).ExecuteReply(ctx, req.(*ExecuteReplyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Done_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DoneRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Done(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Done_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Done(ctx, req.(*DoneRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Log_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LogRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Log(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Log_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Log(ctx, req.(*LogRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Print_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrintRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Print(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Print_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Print(ctx, req.(*PrintRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Sleep_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SleepRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Sleep(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Sleep_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Sleep(ctx, req.(*SleepRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Subscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubscribeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Subscribe(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Subscribe_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Subscribe(ctx, req.(*SubscribeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_NextEvent_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NextEventRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).NextEvent(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_NextEvent_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).NextEvent(ctx, req.(*NextEventRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Unsubscribe_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UnsubscribeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Unsubscribe(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Unsubscribe_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Unsubscribe(ctx, req.(*UnsubscribeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_StartSession_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartSessionRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).StartSession(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_StartSession_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).StartSession(ctx, req.(*StartSessionRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Signal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SignalRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Signal(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Signal_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Signal(ctx, req.(*SignalRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_NextSignal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NextSignalRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).NextSignal(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_NextSignal_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).NextSignal(ctx, req.(*NextSignalRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_StoreList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreListRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).StoreList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_StoreList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).StoreList(ctx, req.(*StoreListRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_StoreMutate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StoreMutateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).StoreMutate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_StoreMutate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).StoreMutate(ctx, req.(*StoreMutateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Outcome_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(OutcomeRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Outcome(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Outcome_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Outcome(ctx, req.(*OutcomeRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_EncodeJWT_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EncodeJWTRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).EncodeJWT(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_EncodeJWT_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).EncodeJWT(ctx, req.(*EncodeJWTRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_RefreshOAuthToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RefreshRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).RefreshOAuthToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_RefreshOAuthToken_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).RefreshOAuthToken(ctx, req.(*RefreshRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_Health_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HandlerHealthRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).Health(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_Health_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).Health(ctx, req.(*HandlerHealthRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _HandlerService_IsActiveRunner_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IsActiveRunnerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(HandlerServiceServer).IsActiveRunner(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: HandlerService_IsActiveRunner_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(HandlerServiceServer).IsActiveRunner(ctx, req.(*IsActiveRunnerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// HandlerService_ServiceDesc is the grpc.ServiceDesc for HandlerService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var HandlerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "autokitteh.user_code.v1.HandlerService",
	HandlerType: (*HandlerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Activity",
			Handler:    _HandlerService_Activity_Handler,
		},
		{
			MethodName: "ExecuteReply",
			Handler:    _HandlerService_ExecuteReply_Handler,
		},
		{
			MethodName: "Done",
			Handler:    _HandlerService_Done_Handler,
		},
		{
			MethodName: "Log",
			Handler:    _HandlerService_Log_Handler,
		},
		{
			MethodName: "Print",
			Handler:    _HandlerService_Print_Handler,
		},
		{
			MethodName: "Sleep",
			Handler:    _HandlerService_Sleep_Handler,
		},
		{
			MethodName: "Subscribe",
			Handler:    _HandlerService_Subscribe_Handler,
		},
		{
			MethodName: "NextEvent",
			Handler:    _HandlerService_NextEvent_Handler,
		},
		{
			MethodName: "Unsubscribe",
			Handler:    _HandlerService_Unsubscribe_Handler,
		},
		{
			MethodName: "StartSession",
			Handler:    _HandlerService_StartSession_Handler,
		},
		{
			MethodName: "Signal",
			Handler:    _HandlerService_Signal_Handler,
		},
		{
			MethodName: "NextSignal",
			Handler:    _HandlerService_NextSignal_Handler,
		},
		{
			MethodName: "StoreList",
			Handler:    _HandlerService_StoreList_Handler,
		},
		{
			MethodName: "StoreMutate",
			Handler:    _HandlerService_StoreMutate_Handler,
		},
		{
			MethodName: "Outcome",
			Handler:    _HandlerService_Outcome_Handler,
		},
		{
			MethodName: "EncodeJWT",
			Handler:    _HandlerService_EncodeJWT_Handler,
		},
		{
			MethodName: "RefreshOAuthToken",
			Handler:    _HandlerService_RefreshOAuthToken_Handler,
		},
		{
			MethodName: "Health",
			Handler:    _HandlerService_Health_Handler,
		},
		{
			MethodName: "IsActiveRunner",
			Handler:    _HandlerService_IsActiveRunner_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "autokitteh/user_code/v1/handler_svc.proto",
}
