// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             (unknown)
// source: replay/replay.proto

package replay

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

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

const (
	ReplayService_CreateReplay_FullMethodName = "/replay.ReplayService/CreateReplay"
	ReplayService_ListReplays_FullMethodName  = "/replay.ReplayService/ListReplays"
	ReplayService_GetReplay_FullMethodName    = "/replay.ReplayService/GetReplay"
	ReplayService_UpdateReplay_FullMethodName = "/replay.ReplayService/UpdateReplay"
	ReplayService_DeleteReplay_FullMethodName = "/replay.ReplayService/DeleteReplay"
	ReplayService_StartReplay_FullMethodName  = "/replay.ReplayService/StartReplay"
	ReplayService_StopReplay_FullMethodName   = "/replay.ReplayService/StopReplay"
)

// ReplayServiceClient is the client API for ReplayService 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 ReplayServiceClient interface {
	// CreateReplay creates a new replay task
	CreateReplay(ctx context.Context, in *CreateReplayRequest, opts ...grpc.CallOption) (*CreateReplayResponse, error)
	// ListReplays lists all replay tasks for a cluster or organization
	ListReplays(ctx context.Context, in *ListReplaysRequest, opts ...grpc.CallOption) (*ListReplaysResponse, error)
	// GetReplay retrieves a replay task by ID
	GetReplay(ctx context.Context, in *GetReplayRequest, opts ...grpc.CallOption) (*GetReplayResponse, error)
	// UpdateReplay updates an existing replay task configuration
	UpdateReplay(ctx context.Context, in *UpdateReplayRequest, opts ...grpc.CallOption) (*UpdateReplayResponse, error)
	// DeleteReplay deletes a replay task
	DeleteReplay(ctx context.Context, in *DeleteReplayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// StartReplay starts a replay task
	StartReplay(ctx context.Context, in *StartReplayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// StopReplay stops a running replay task
	StopReplay(ctx context.Context, in *StopReplayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type replayServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewReplayServiceClient(cc grpc.ClientConnInterface) ReplayServiceClient {
	return &replayServiceClient{cc}
}

func (c *replayServiceClient) CreateReplay(ctx context.Context, in *CreateReplayRequest, opts ...grpc.CallOption) (*CreateReplayResponse, error) {
	out := new(CreateReplayResponse)
	err := c.cc.Invoke(ctx, ReplayService_CreateReplay_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replayServiceClient) ListReplays(ctx context.Context, in *ListReplaysRequest, opts ...grpc.CallOption) (*ListReplaysResponse, error) {
	out := new(ListReplaysResponse)
	err := c.cc.Invoke(ctx, ReplayService_ListReplays_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replayServiceClient) GetReplay(ctx context.Context, in *GetReplayRequest, opts ...grpc.CallOption) (*GetReplayResponse, error) {
	out := new(GetReplayResponse)
	err := c.cc.Invoke(ctx, ReplayService_GetReplay_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replayServiceClient) UpdateReplay(ctx context.Context, in *UpdateReplayRequest, opts ...grpc.CallOption) (*UpdateReplayResponse, error) {
	out := new(UpdateReplayResponse)
	err := c.cc.Invoke(ctx, ReplayService_UpdateReplay_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replayServiceClient) DeleteReplay(ctx context.Context, in *DeleteReplayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ReplayService_DeleteReplay_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replayServiceClient) StartReplay(ctx context.Context, in *StartReplayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ReplayService_StartReplay_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *replayServiceClient) StopReplay(ctx context.Context, in *StopReplayRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ReplayService_StopReplay_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ReplayServiceServer is the server API for ReplayService service.
// All implementations must embed UnimplementedReplayServiceServer
// for forward compatibility
type ReplayServiceServer interface {
	// CreateReplay creates a new replay task
	CreateReplay(context.Context, *CreateReplayRequest) (*CreateReplayResponse, error)
	// ListReplays lists all replay tasks for a cluster or organization
	ListReplays(context.Context, *ListReplaysRequest) (*ListReplaysResponse, error)
	// GetReplay retrieves a replay task by ID
	GetReplay(context.Context, *GetReplayRequest) (*GetReplayResponse, error)
	// UpdateReplay updates an existing replay task configuration
	UpdateReplay(context.Context, *UpdateReplayRequest) (*UpdateReplayResponse, error)
	// DeleteReplay deletes a replay task
	DeleteReplay(context.Context, *DeleteReplayRequest) (*emptypb.Empty, error)
	// StartReplay starts a replay task
	StartReplay(context.Context, *StartReplayRequest) (*emptypb.Empty, error)
	// StopReplay stops a running replay task
	StopReplay(context.Context, *StopReplayRequest) (*emptypb.Empty, error)
	mustEmbedUnimplementedReplayServiceServer()
}

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

func (UnimplementedReplayServiceServer) CreateReplay(context.Context, *CreateReplayRequest) (*CreateReplayResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateReplay not implemented")
}
func (UnimplementedReplayServiceServer) ListReplays(context.Context, *ListReplaysRequest) (*ListReplaysResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListReplays not implemented")
}
func (UnimplementedReplayServiceServer) GetReplay(context.Context, *GetReplayRequest) (*GetReplayResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetReplay not implemented")
}
func (UnimplementedReplayServiceServer) UpdateReplay(context.Context, *UpdateReplayRequest) (*UpdateReplayResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateReplay not implemented")
}
func (UnimplementedReplayServiceServer) DeleteReplay(context.Context, *DeleteReplayRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteReplay not implemented")
}
func (UnimplementedReplayServiceServer) StartReplay(context.Context, *StartReplayRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartReplay not implemented")
}
func (UnimplementedReplayServiceServer) StopReplay(context.Context, *StopReplayRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopReplay not implemented")
}
func (UnimplementedReplayServiceServer) mustEmbedUnimplementedReplayServiceServer() {}

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

func RegisterReplayServiceServer(s grpc.ServiceRegistrar, srv ReplayServiceServer) {
	s.RegisterService(&ReplayService_ServiceDesc, srv)
}

func _ReplayService_CreateReplay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateReplayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplayServiceServer).CreateReplay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReplayService_CreateReplay_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplayServiceServer).CreateReplay(ctx, req.(*CreateReplayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplayService_ListReplays_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListReplaysRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplayServiceServer).ListReplays(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReplayService_ListReplays_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplayServiceServer).ListReplays(ctx, req.(*ListReplaysRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplayService_GetReplay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetReplayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplayServiceServer).GetReplay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReplayService_GetReplay_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplayServiceServer).GetReplay(ctx, req.(*GetReplayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplayService_UpdateReplay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateReplayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplayServiceServer).UpdateReplay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReplayService_UpdateReplay_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplayServiceServer).UpdateReplay(ctx, req.(*UpdateReplayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplayService_DeleteReplay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteReplayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplayServiceServer).DeleteReplay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReplayService_DeleteReplay_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplayServiceServer).DeleteReplay(ctx, req.(*DeleteReplayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplayService_StartReplay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StartReplayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplayServiceServer).StartReplay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReplayService_StartReplay_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplayServiceServer).StartReplay(ctx, req.(*StartReplayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ReplayService_StopReplay_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StopReplayRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ReplayServiceServer).StopReplay(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ReplayService_StopReplay_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ReplayServiceServer).StopReplay(ctx, req.(*StopReplayRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// ReplayService_ServiceDesc is the grpc.ServiceDesc for ReplayService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ReplayService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "replay.ReplayService",
	HandlerType: (*ReplayServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateReplay",
			Handler:    _ReplayService_CreateReplay_Handler,
		},
		{
			MethodName: "ListReplays",
			Handler:    _ReplayService_ListReplays_Handler,
		},
		{
			MethodName: "GetReplay",
			Handler:    _ReplayService_GetReplay_Handler,
		},
		{
			MethodName: "UpdateReplay",
			Handler:    _ReplayService_UpdateReplay_Handler,
		},
		{
			MethodName: "DeleteReplay",
			Handler:    _ReplayService_DeleteReplay_Handler,
		},
		{
			MethodName: "StartReplay",
			Handler:    _ReplayService_StartReplay_Handler,
		},
		{
			MethodName: "StopReplay",
			Handler:    _ReplayService_StopReplay_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "replay/replay.proto",
}