// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v4.25.1
// source: backend_repo.proto

package proto

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

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

const (
	BackendRepositoryService_GetCheckpointById_FullMethodName           = "/BackendRepositoryService/GetCheckpointById"
	BackendRepositoryService_GetLatestCheckpointByStubId_FullMethodName = "/BackendRepositoryService/GetLatestCheckpointByStubId"
	BackendRepositoryService_ListCheckpoints_FullMethodName             = "/BackendRepositoryService/ListCheckpoints"
	BackendRepositoryService_CreateCheckpoint_FullMethodName            = "/BackendRepositoryService/CreateCheckpoint"
	BackendRepositoryService_UpdateCheckpoint_FullMethodName            = "/BackendRepositoryService/UpdateCheckpoint"
)

// BackendRepositoryServiceClient is the client API for BackendRepositoryService 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 BackendRepositoryServiceClient interface {
	GetCheckpointById(ctx context.Context, in *GetCheckpointByIdRequest, opts ...grpc.CallOption) (*GetCheckpointByIdResponse, error)
	GetLatestCheckpointByStubId(ctx context.Context, in *GetLatestCheckpointByStubIdRequest, opts ...grpc.CallOption) (*GetLatestCheckpointByStubIdResponse, error)
	ListCheckpoints(ctx context.Context, in *ListCheckpointsRequest, opts ...grpc.CallOption) (*ListCheckpointsResponse, error)
	CreateCheckpoint(ctx context.Context, in *CreateCheckpointRequest, opts ...grpc.CallOption) (*CreateCheckpointResponse, error)
	UpdateCheckpoint(ctx context.Context, in *UpdateCheckpointRequest, opts ...grpc.CallOption) (*UpdateCheckpointResponse, error)
}

type backendRepositoryServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewBackendRepositoryServiceClient(cc grpc.ClientConnInterface) BackendRepositoryServiceClient {
	return &backendRepositoryServiceClient{cc}
}

func (c *backendRepositoryServiceClient) GetCheckpointById(ctx context.Context, in *GetCheckpointByIdRequest, opts ...grpc.CallOption) (*GetCheckpointByIdResponse, error) {
	out := new(GetCheckpointByIdResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_GetCheckpointById_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) GetLatestCheckpointByStubId(ctx context.Context, in *GetLatestCheckpointByStubIdRequest, opts ...grpc.CallOption) (*GetLatestCheckpointByStubIdResponse, error) {
	out := new(GetLatestCheckpointByStubIdResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_GetLatestCheckpointByStubId_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) ListCheckpoints(ctx context.Context, in *ListCheckpointsRequest, opts ...grpc.CallOption) (*ListCheckpointsResponse, error) {
	out := new(ListCheckpointsResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_ListCheckpoints_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) CreateCheckpoint(ctx context.Context, in *CreateCheckpointRequest, opts ...grpc.CallOption) (*CreateCheckpointResponse, error) {
	out := new(CreateCheckpointResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_CreateCheckpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) UpdateCheckpoint(ctx context.Context, in *UpdateCheckpointRequest, opts ...grpc.CallOption) (*UpdateCheckpointResponse, error) {
	out := new(UpdateCheckpointResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_UpdateCheckpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BackendRepositoryServiceServer is the server API for BackendRepositoryService service.
// All implementations must embed UnimplementedBackendRepositoryServiceServer
// for forward compatibility
type BackendRepositoryServiceServer interface {
	GetCheckpointById(context.Context, *GetCheckpointByIdRequest) (*GetCheckpointByIdResponse, error)
	GetLatestCheckpointByStubId(context.Context, *GetLatestCheckpointByStubIdRequest) (*GetLatestCheckpointByStubIdResponse, error)
	ListCheckpoints(context.Context, *ListCheckpointsRequest) (*ListCheckpointsResponse, error)
	CreateCheckpoint(context.Context, *CreateCheckpointRequest) (*CreateCheckpointResponse, error)
	UpdateCheckpoint(context.Context, *UpdateCheckpointRequest) (*UpdateCheckpointResponse, error)
	mustEmbedUnimplementedBackendRepositoryServiceServer()
}

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

func (UnimplementedBackendRepositoryServiceServer) GetCheckpointById(context.Context, *GetCheckpointByIdRequest) (*GetCheckpointByIdResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCheckpointById not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) GetLatestCheckpointByStubId(context.Context, *GetLatestCheckpointByStubIdRequest) (*GetLatestCheckpointByStubIdResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLatestCheckpointByStubId not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) ListCheckpoints(context.Context, *ListCheckpointsRequest) (*ListCheckpointsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCheckpoints not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) CreateCheckpoint(context.Context, *CreateCheckpointRequest) (*CreateCheckpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCheckpoint not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) UpdateCheckpoint(context.Context, *UpdateCheckpointRequest) (*UpdateCheckpointResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateCheckpoint not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) mustEmbedUnimplementedBackendRepositoryServiceServer() {
}

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

func RegisterBackendRepositoryServiceServer(s grpc.ServiceRegistrar, srv BackendRepositoryServiceServer) {
	s.RegisterService(&BackendRepositoryService_ServiceDesc, srv)
}

func _BackendRepositoryService_GetCheckpointById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetCheckpointByIdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackendRepositoryServiceServer).GetCheckpointById(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackendRepositoryService_GetCheckpointById_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackendRepositoryServiceServer).GetCheckpointById(ctx, req.(*GetCheckpointByIdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackendRepositoryService_GetLatestCheckpointByStubId_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetLatestCheckpointByStubIdRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackendRepositoryServiceServer).GetLatestCheckpointByStubId(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackendRepositoryService_GetLatestCheckpointByStubId_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackendRepositoryServiceServer).GetLatestCheckpointByStubId(ctx, req.(*GetLatestCheckpointByStubIdRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackendRepositoryService_ListCheckpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListCheckpointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackendRepositoryServiceServer).ListCheckpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackendRepositoryService_ListCheckpoints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackendRepositoryServiceServer).ListCheckpoints(ctx, req.(*ListCheckpointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackendRepositoryService_CreateCheckpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateCheckpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackendRepositoryServiceServer).CreateCheckpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackendRepositoryService_CreateCheckpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackendRepositoryServiceServer).CreateCheckpoint(ctx, req.(*CreateCheckpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackendRepositoryService_UpdateCheckpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateCheckpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackendRepositoryServiceServer).UpdateCheckpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackendRepositoryService_UpdateCheckpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackendRepositoryServiceServer).UpdateCheckpoint(ctx, req.(*UpdateCheckpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// BackendRepositoryService_ServiceDesc is the grpc.ServiceDesc for BackendRepositoryService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var BackendRepositoryService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "BackendRepositoryService",
	HandlerType: (*BackendRepositoryServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetCheckpointById",
			Handler:    _BackendRepositoryService_GetCheckpointById_Handler,
		},
		{
			MethodName: "GetLatestCheckpointByStubId",
			Handler:    _BackendRepositoryService_GetLatestCheckpointByStubId_Handler,
		},
		{
			MethodName: "ListCheckpoints",
			Handler:    _BackendRepositoryService_ListCheckpoints_Handler,
		},
		{
			MethodName: "CreateCheckpoint",
			Handler:    _BackendRepositoryService_CreateCheckpoint_Handler,
		},
		{
			MethodName: "UpdateCheckpoint",
			Handler:    _BackendRepositoryService_UpdateCheckpoint_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "backend_repo.proto",
}
