// 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"
	BackendRepositoryService_CreateDiskSnapshot_FullMethodName          = "/BackendRepositoryService/CreateDiskSnapshot"
	BackendRepositoryService_FailDiskSnapshot_FullMethodName            = "/BackendRepositoryService/FailDiskSnapshot"
	BackendRepositoryService_GetLatestDiskSnapshot_FullMethodName       = "/BackendRepositoryService/GetLatestDiskSnapshot"
	BackendRepositoryService_GetDiskSnapshot_FullMethodName             = "/BackendRepositoryService/GetDiskSnapshot"
	BackendRepositoryService_GetDiskSnapshotDownloadURL_FullMethodName  = "/BackendRepositoryService/GetDiskSnapshotDownloadURL"
	BackendRepositoryService_PreemptVM_FullMethodName                   = "/BackendRepositoryService/PreemptVM"
)

// 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)
	CreateDiskSnapshot(ctx context.Context, in *CreateDiskSnapshotRequest, opts ...grpc.CallOption) (*CreateDiskSnapshotResponse, error)
	FailDiskSnapshot(ctx context.Context, in *FailDiskSnapshotRequest, opts ...grpc.CallOption) (*FailDiskSnapshotResponse, error)
	GetLatestDiskSnapshot(ctx context.Context, in *GetLatestDiskSnapshotRequest, opts ...grpc.CallOption) (*GetLatestDiskSnapshotResponse, error)
	GetDiskSnapshot(ctx context.Context, in *GetDiskSnapshotRequest, opts ...grpc.CallOption) (*GetDiskSnapshotResponse, error)
	GetDiskSnapshotDownloadURL(ctx context.Context, in *GetDiskSnapshotDownloadURLRequest, opts ...grpc.CallOption) (*GetDiskSnapshotDownloadURLResponse, error)
	PreemptVM(ctx context.Context, in *PreemptVMRequest, opts ...grpc.CallOption) (*PreemptVMResponse, 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
}

func (c *backendRepositoryServiceClient) CreateDiskSnapshot(ctx context.Context, in *CreateDiskSnapshotRequest, opts ...grpc.CallOption) (*CreateDiskSnapshotResponse, error) {
	out := new(CreateDiskSnapshotResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_CreateDiskSnapshot_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) FailDiskSnapshot(ctx context.Context, in *FailDiskSnapshotRequest, opts ...grpc.CallOption) (*FailDiskSnapshotResponse, error) {
	out := new(FailDiskSnapshotResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_FailDiskSnapshot_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) GetLatestDiskSnapshot(ctx context.Context, in *GetLatestDiskSnapshotRequest, opts ...grpc.CallOption) (*GetLatestDiskSnapshotResponse, error) {
	out := new(GetLatestDiskSnapshotResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_GetLatestDiskSnapshot_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) GetDiskSnapshot(ctx context.Context, in *GetDiskSnapshotRequest, opts ...grpc.CallOption) (*GetDiskSnapshotResponse, error) {
	out := new(GetDiskSnapshotResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_GetDiskSnapshot_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) GetDiskSnapshotDownloadURL(ctx context.Context, in *GetDiskSnapshotDownloadURLRequest, opts ...grpc.CallOption) (*GetDiskSnapshotDownloadURLResponse, error) {
	out := new(GetDiskSnapshotDownloadURLResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_GetDiskSnapshotDownloadURL_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backendRepositoryServiceClient) PreemptVM(ctx context.Context, in *PreemptVMRequest, opts ...grpc.CallOption) (*PreemptVMResponse, error) {
	out := new(PreemptVMResponse)
	err := c.cc.Invoke(ctx, BackendRepositoryService_PreemptVM_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)
	CreateDiskSnapshot(context.Context, *CreateDiskSnapshotRequest) (*CreateDiskSnapshotResponse, error)
	FailDiskSnapshot(context.Context, *FailDiskSnapshotRequest) (*FailDiskSnapshotResponse, error)
	GetLatestDiskSnapshot(context.Context, *GetLatestDiskSnapshotRequest) (*GetLatestDiskSnapshotResponse, error)
	GetDiskSnapshot(context.Context, *GetDiskSnapshotRequest) (*GetDiskSnapshotResponse, error)
	GetDiskSnapshotDownloadURL(context.Context, *GetDiskSnapshotDownloadURLRequest) (*GetDiskSnapshotDownloadURLResponse, error)
	PreemptVM(context.Context, *PreemptVMRequest) (*PreemptVMResponse, 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) CreateDiskSnapshot(context.Context, *CreateDiskSnapshotRequest) (*CreateDiskSnapshotResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateDiskSnapshot not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) FailDiskSnapshot(context.Context, *FailDiskSnapshotRequest) (*FailDiskSnapshotResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method FailDiskSnapshot not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) GetLatestDiskSnapshot(context.Context, *GetLatestDiskSnapshotRequest) (*GetLatestDiskSnapshotResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetLatestDiskSnapshot not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) GetDiskSnapshot(context.Context, *GetDiskSnapshotRequest) (*GetDiskSnapshotResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDiskSnapshot not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) GetDiskSnapshotDownloadURL(context.Context, *GetDiskSnapshotDownloadURLRequest) (*GetDiskSnapshotDownloadURLResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDiskSnapshotDownloadURL not implemented")
}
func (UnimplementedBackendRepositoryServiceServer) PreemptVM(context.Context, *PreemptVMRequest) (*PreemptVMResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PreemptVM 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)
}

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

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

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

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

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

func _BackendRepositoryService_PreemptVM_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PreemptVMRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackendRepositoryServiceServer).PreemptVM(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackendRepositoryService_PreemptVM_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackendRepositoryServiceServer).PreemptVM(ctx, req.(*PreemptVMRequest))
	}
	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,
		},
		{
			MethodName: "CreateDiskSnapshot",
			Handler:    _BackendRepositoryService_CreateDiskSnapshot_Handler,
		},
		{
			MethodName: "FailDiskSnapshot",
			Handler:    _BackendRepositoryService_FailDiskSnapshot_Handler,
		},
		{
			MethodName: "GetLatestDiskSnapshot",
			Handler:    _BackendRepositoryService_GetLatestDiskSnapshot_Handler,
		},
		{
			MethodName: "GetDiskSnapshot",
			Handler:    _BackendRepositoryService_GetDiskSnapshot_Handler,
		},
		{
			MethodName: "GetDiskSnapshotDownloadURL",
			Handler:    _BackendRepositoryService_GetDiskSnapshotDownloadURL_Handler,
		},
		{
			MethodName: "PreemptVM",
			Handler:    _BackendRepositoryService_PreemptVM_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "backend_repo.proto",
}