pcm-slurm/slurm/slurm_grpc.pb.go

// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.2.0
// - protoc             v3.19.4
// source: slurm.proto

package slurm

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

// SlurmClient is the client API for Slurm 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 SlurmClient interface {
	SyncToken(ctx context.Context, in *SyncTokenReq, opts ...grpc.CallOption) (*SyncTokenResp, error)
	Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingResp, error)
	ListJob(ctx context.Context, in *ListJobReq, opts ...grpc.CallOption) (*ListJobResp, error)
	GetJob(ctx context.Context, in *GetJobReq, opts ...grpc.CallOption) (*GetJobResp, error)
	UpdateJob(ctx context.Context, in *UpdateJobReq, opts ...grpc.CallOption) (*UpdateJobResp, error)
	CancelJob(ctx context.Context, in *CancelJobReq, opts ...grpc.CallOption) (*CancelJobResp, error)
	SubmitJob(ctx context.Context, in *SubmitJobReq, opts ...grpc.CallOption) (*SubmitJobResp, error)
	ListUser(ctx context.Context, in *ListUserReq, opts ...grpc.CallOption) (*ListUserResp, error)
	GetUser(ctx context.Context, in *GetUserReq, opts ...grpc.CallOption) (*GetUserResp, error)
	UpdateUser(ctx context.Context, in *UpdateUserReq, opts ...grpc.CallOption) (*UpdateUserResp, error)
	DeleteUser(ctx context.Context, in *DeleteUserReq, opts ...grpc.CallOption) (*DeleteUserResp, error)
	ListPartition(ctx context.Context, in *ListPartitionReq, opts ...grpc.CallOption) (*ListPartitionResp, error)
	GetPartition(ctx context.Context, in *GetPartitionReq, opts ...grpc.CallOption) (*GetPartitionResp, error)
	ListNode(ctx context.Context, in *ListNodeReq, opts ...grpc.CallOption) (*ListNodeResp, error)
	GetNode(ctx context.Context, in *GetNodeReq, opts ...grpc.CallOption) (*GetNodeResp, error)
	ListReservation(ctx context.Context, in *ListReservationReq, opts ...grpc.CallOption) (*ListReservationResp, error)
	GetReservation(ctx context.Context, in *GetReservationReq, opts ...grpc.CallOption) (*GetReservationResp, error)
	LoadConfiguration(ctx context.Context, in *LoadConfigurationReq, opts ...grpc.CallOption) (*LoadConfigurationResp, error)
	DumpConfiguration(ctx context.Context, in *DumpConfigurationReq, opts ...grpc.CallOption) (*DumpConfigurationResp, error)
	ListQos(ctx context.Context, in *ListQosReq, opts ...grpc.CallOption) (*ListQosResp, error)
	GetQos(ctx context.Context, in *GetQosReq, opts ...grpc.CallOption) (*GetQosResp, error)
	DeleteQos(ctx context.Context, in *DeleteQosReq, opts ...grpc.CallOption) (*DeleteQosResp, error)
	ListTres(ctx context.Context, in *ListTresReq, opts ...grpc.CallOption) (*ListTresResp, error)
	SetTres(ctx context.Context, in *SetTresReq, opts ...grpc.CallOption) (*SetTresResp, error)
	ListAccount(ctx context.Context, in *ListAccountReq, opts ...grpc.CallOption) (*ListAccountResp, error)
	GetAccount(ctx context.Context, in *GetAccountReq, opts ...grpc.CallOption) (*GetAccountResp, error)
	UpdateAccount(ctx context.Context, in *UpdateAccountReq, opts ...grpc.CallOption) (*UpdateAccountResp, error)
	DeleteAccount(ctx context.Context, in *DeleteAccountReq, opts ...grpc.CallOption) (*DeleteAccountResp, error)
	ListCluster(ctx context.Context, in *ListClusterReq, opts ...grpc.CallOption) (*ListClusterResp, error)
	GetCluster(ctx context.Context, in *GetClusterReq, opts ...grpc.CallOption) (*GetClusterResp, error)
	AddCluster(ctx context.Context, in *AddClusterReq, opts ...grpc.CallOption) (*AddClusterResp, error)
	DeleteCluster(ctx context.Context, in *DeleteClusterReq, opts ...grpc.CallOption) (*DeleteClusterResp, error)
	ListWckey(ctx context.Context, in *ListWckeyReq, opts ...grpc.CallOption) (*ListWckeyResp, error)
	GetWckey(ctx context.Context, in *GetWckeyReq, opts ...grpc.CallOption) (*GetWckeyResp, error)
	AddWckey(ctx context.Context, in *AddWckeyReq, opts ...grpc.CallOption) (*AddWckeyResp, error)
	DeleteWckey(ctx context.Context, in *DeleteWckeyReq, opts ...grpc.CallOption) (*DeleteWckeyResp, error)
	ListAssociation(ctx context.Context, in *ListAssociationReq, opts ...grpc.CallOption) (*ListAssociationResp, error)
	GetAssociation(ctx context.Context, in *GetAssociationReq, opts ...grpc.CallOption) (*GetAssociationResp, error)
	SetAssociation(ctx context.Context, in *SetAssociationReq, opts ...grpc.CallOption) (*SetAssociationResp, error)
	DeleteAssociation(ctx context.Context, in *DeleteAssociationReq, opts ...grpc.CallOption) (*DeleteAssociationResp, error)
	GetDiagnostics(ctx context.Context, in *ListDiagnosticsReq, opts ...grpc.CallOption) (*ListDiagnosticsResp, error)
	GetDbDiagnostics(ctx context.Context, in *ListDbDiagnosticsReq, opts ...grpc.CallOption) (*ListDbDiagnosticsResp, error)
}

type slurmClient struct {
	cc grpc.ClientConnInterface
}

func NewSlurmClient(cc grpc.ClientConnInterface) SlurmClient {
	return &slurmClient{cc}
}

func (c *slurmClient) SyncToken(ctx context.Context, in *SyncTokenReq, opts ...grpc.CallOption) (*SyncTokenResp, error) {
	out := new(SyncTokenResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/syncToken", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) Ping(ctx context.Context, in *PingReq, opts ...grpc.CallOption) (*PingResp, error) {
	out := new(PingResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/ping", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListJob(ctx context.Context, in *ListJobReq, opts ...grpc.CallOption) (*ListJobResp, error) {
	out := new(ListJobResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetJob(ctx context.Context, in *GetJobReq, opts ...grpc.CallOption) (*GetJobResp, error) {
	out := new(GetJobResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) UpdateJob(ctx context.Context, in *UpdateJobReq, opts ...grpc.CallOption) (*UpdateJobResp, error) {
	out := new(UpdateJobResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/updateJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) CancelJob(ctx context.Context, in *CancelJobReq, opts ...grpc.CallOption) (*CancelJobResp, error) {
	out := new(CancelJobResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/cancelJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) SubmitJob(ctx context.Context, in *SubmitJobReq, opts ...grpc.CallOption) (*SubmitJobResp, error) {
	out := new(SubmitJobResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/submitJob", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListUser(ctx context.Context, in *ListUserReq, opts ...grpc.CallOption) (*ListUserResp, error) {
	out := new(ListUserResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetUser(ctx context.Context, in *GetUserReq, opts ...grpc.CallOption) (*GetUserResp, error) {
	out := new(GetUserResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) UpdateUser(ctx context.Context, in *UpdateUserReq, opts ...grpc.CallOption) (*UpdateUserResp, error) {
	out := new(UpdateUserResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/updateUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) DeleteUser(ctx context.Context, in *DeleteUserReq, opts ...grpc.CallOption) (*DeleteUserResp, error) {
	out := new(DeleteUserResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/deleteUser", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListPartition(ctx context.Context, in *ListPartitionReq, opts ...grpc.CallOption) (*ListPartitionResp, error) {
	out := new(ListPartitionResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listPartition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetPartition(ctx context.Context, in *GetPartitionReq, opts ...grpc.CallOption) (*GetPartitionResp, error) {
	out := new(GetPartitionResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getPartition", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListNode(ctx context.Context, in *ListNodeReq, opts ...grpc.CallOption) (*ListNodeResp, error) {
	out := new(ListNodeResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetNode(ctx context.Context, in *GetNodeReq, opts ...grpc.CallOption) (*GetNodeResp, error) {
	out := new(GetNodeResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListReservation(ctx context.Context, in *ListReservationReq, opts ...grpc.CallOption) (*ListReservationResp, error) {
	out := new(ListReservationResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listReservation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetReservation(ctx context.Context, in *GetReservationReq, opts ...grpc.CallOption) (*GetReservationResp, error) {
	out := new(GetReservationResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getReservation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) LoadConfiguration(ctx context.Context, in *LoadConfigurationReq, opts ...grpc.CallOption) (*LoadConfigurationResp, error) {
	out := new(LoadConfigurationResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/loadConfiguration", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) DumpConfiguration(ctx context.Context, in *DumpConfigurationReq, opts ...grpc.CallOption) (*DumpConfigurationResp, error) {
	out := new(DumpConfigurationResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/dumpConfiguration", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListQos(ctx context.Context, in *ListQosReq, opts ...grpc.CallOption) (*ListQosResp, error) {
	out := new(ListQosResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listQos", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetQos(ctx context.Context, in *GetQosReq, opts ...grpc.CallOption) (*GetQosResp, error) {
	out := new(GetQosResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getQos", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) DeleteQos(ctx context.Context, in *DeleteQosReq, opts ...grpc.CallOption) (*DeleteQosResp, error) {
	out := new(DeleteQosResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/deleteQos", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListTres(ctx context.Context, in *ListTresReq, opts ...grpc.CallOption) (*ListTresResp, error) {
	out := new(ListTresResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listTres", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) SetTres(ctx context.Context, in *SetTresReq, opts ...grpc.CallOption) (*SetTresResp, error) {
	out := new(SetTresResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/setTres", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListAccount(ctx context.Context, in *ListAccountReq, opts ...grpc.CallOption) (*ListAccountResp, error) {
	out := new(ListAccountResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetAccount(ctx context.Context, in *GetAccountReq, opts ...grpc.CallOption) (*GetAccountResp, error) {
	out := new(GetAccountResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) UpdateAccount(ctx context.Context, in *UpdateAccountReq, opts ...grpc.CallOption) (*UpdateAccountResp, error) {
	out := new(UpdateAccountResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/updateAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) DeleteAccount(ctx context.Context, in *DeleteAccountReq, opts ...grpc.CallOption) (*DeleteAccountResp, error) {
	out := new(DeleteAccountResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/deleteAccount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListCluster(ctx context.Context, in *ListClusterReq, opts ...grpc.CallOption) (*ListClusterResp, error) {
	out := new(ListClusterResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetCluster(ctx context.Context, in *GetClusterReq, opts ...grpc.CallOption) (*GetClusterResp, error) {
	out := new(GetClusterResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) AddCluster(ctx context.Context, in *AddClusterReq, opts ...grpc.CallOption) (*AddClusterResp, error) {
	out := new(AddClusterResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/addCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) DeleteCluster(ctx context.Context, in *DeleteClusterReq, opts ...grpc.CallOption) (*DeleteClusterResp, error) {
	out := new(DeleteClusterResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/deleteCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListWckey(ctx context.Context, in *ListWckeyReq, opts ...grpc.CallOption) (*ListWckeyResp, error) {
	out := new(ListWckeyResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listWckey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetWckey(ctx context.Context, in *GetWckeyReq, opts ...grpc.CallOption) (*GetWckeyResp, error) {
	out := new(GetWckeyResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getWckey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) AddWckey(ctx context.Context, in *AddWckeyReq, opts ...grpc.CallOption) (*AddWckeyResp, error) {
	out := new(AddWckeyResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/addWckey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) DeleteWckey(ctx context.Context, in *DeleteWckeyReq, opts ...grpc.CallOption) (*DeleteWckeyResp, error) {
	out := new(DeleteWckeyResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/deleteWckey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) ListAssociation(ctx context.Context, in *ListAssociationReq, opts ...grpc.CallOption) (*ListAssociationResp, error) {
	out := new(ListAssociationResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/listAssociation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetAssociation(ctx context.Context, in *GetAssociationReq, opts ...grpc.CallOption) (*GetAssociationResp, error) {
	out := new(GetAssociationResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getAssociation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) SetAssociation(ctx context.Context, in *SetAssociationReq, opts ...grpc.CallOption) (*SetAssociationResp, error) {
	out := new(SetAssociationResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/setAssociation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) DeleteAssociation(ctx context.Context, in *DeleteAssociationReq, opts ...grpc.CallOption) (*DeleteAssociationResp, error) {
	out := new(DeleteAssociationResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/deleteAssociation", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetDiagnostics(ctx context.Context, in *ListDiagnosticsReq, opts ...grpc.CallOption) (*ListDiagnosticsResp, error) {
	out := new(ListDiagnosticsResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getDiagnostics", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *slurmClient) GetDbDiagnostics(ctx context.Context, in *ListDbDiagnosticsReq, opts ...grpc.CallOption) (*ListDbDiagnosticsResp, error) {
	out := new(ListDbDiagnosticsResp)
	err := c.cc.Invoke(ctx, "/slurm.slurm/getDbDiagnostics", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SlurmServer is the server API for Slurm service.
// All implementations must embed UnimplementedSlurmServer
// for forward compatibility
type SlurmServer interface {
	SyncToken(context.Context, *SyncTokenReq) (*SyncTokenResp, error)
	Ping(context.Context, *PingReq) (*PingResp, error)
	ListJob(context.Context, *ListJobReq) (*ListJobResp, error)
	GetJob(context.Context, *GetJobReq) (*GetJobResp, error)
	UpdateJob(context.Context, *UpdateJobReq) (*UpdateJobResp, error)
	CancelJob(context.Context, *CancelJobReq) (*CancelJobResp, error)
	SubmitJob(context.Context, *SubmitJobReq) (*SubmitJobResp, error)
	ListUser(context.Context, *ListUserReq) (*ListUserResp, error)
	GetUser(context.Context, *GetUserReq) (*GetUserResp, error)
	UpdateUser(context.Context, *UpdateUserReq) (*UpdateUserResp, error)
	DeleteUser(context.Context, *DeleteUserReq) (*DeleteUserResp, error)
	ListPartition(context.Context, *ListPartitionReq) (*ListPartitionResp, error)
	GetPartition(context.Context, *GetPartitionReq) (*GetPartitionResp, error)
	ListNode(context.Context, *ListNodeReq) (*ListNodeResp, error)
	GetNode(context.Context, *GetNodeReq) (*GetNodeResp, error)
	ListReservation(context.Context, *ListReservationReq) (*ListReservationResp, error)
	GetReservation(context.Context, *GetReservationReq) (*GetReservationResp, error)
	LoadConfiguration(context.Context, *LoadConfigurationReq) (*LoadConfigurationResp, error)
	DumpConfiguration(context.Context, *DumpConfigurationReq) (*DumpConfigurationResp, error)
	ListQos(context.Context, *ListQosReq) (*ListQosResp, error)
	GetQos(context.Context, *GetQosReq) (*GetQosResp, error)
	DeleteQos(context.Context, *DeleteQosReq) (*DeleteQosResp, error)
	ListTres(context.Context, *ListTresReq) (*ListTresResp, error)
	SetTres(context.Context, *SetTresReq) (*SetTresResp, error)
	ListAccount(context.Context, *ListAccountReq) (*ListAccountResp, error)
	GetAccount(context.Context, *GetAccountReq) (*GetAccountResp, error)
	UpdateAccount(context.Context, *UpdateAccountReq) (*UpdateAccountResp, error)
	DeleteAccount(context.Context, *DeleteAccountReq) (*DeleteAccountResp, error)
	ListCluster(context.Context, *ListClusterReq) (*ListClusterResp, error)
	GetCluster(context.Context, *GetClusterReq) (*GetClusterResp, error)
	AddCluster(context.Context, *AddClusterReq) (*AddClusterResp, error)
	DeleteCluster(context.Context, *DeleteClusterReq) (*DeleteClusterResp, error)
	ListWckey(context.Context, *ListWckeyReq) (*ListWckeyResp, error)
	GetWckey(context.Context, *GetWckeyReq) (*GetWckeyResp, error)
	AddWckey(context.Context, *AddWckeyReq) (*AddWckeyResp, error)
	DeleteWckey(context.Context, *DeleteWckeyReq) (*DeleteWckeyResp, error)
	ListAssociation(context.Context, *ListAssociationReq) (*ListAssociationResp, error)
	GetAssociation(context.Context, *GetAssociationReq) (*GetAssociationResp, error)
	SetAssociation(context.Context, *SetAssociationReq) (*SetAssociationResp, error)
	DeleteAssociation(context.Context, *DeleteAssociationReq) (*DeleteAssociationResp, error)
	GetDiagnostics(context.Context, *ListDiagnosticsReq) (*ListDiagnosticsResp, error)
	GetDbDiagnostics(context.Context, *ListDbDiagnosticsReq) (*ListDbDiagnosticsResp, error)
	mustEmbedUnimplementedSlurmServer()
}

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

func (UnimplementedSlurmServer) SyncToken(context.Context, *SyncTokenReq) (*SyncTokenResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SyncToken not implemented")
}
func (UnimplementedSlurmServer) Ping(context.Context, *PingReq) (*PingResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
}
func (UnimplementedSlurmServer) ListJob(context.Context, *ListJobReq) (*ListJobResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListJob not implemented")
}
func (UnimplementedSlurmServer) GetJob(context.Context, *GetJobReq) (*GetJobResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJob not implemented")
}
func (UnimplementedSlurmServer) UpdateJob(context.Context, *UpdateJobReq) (*UpdateJobResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateJob not implemented")
}
func (UnimplementedSlurmServer) CancelJob(context.Context, *CancelJobReq) (*CancelJobResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelJob not implemented")
}
func (UnimplementedSlurmServer) SubmitJob(context.Context, *SubmitJobReq) (*SubmitJobResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SubmitJob not implemented")
}
func (UnimplementedSlurmServer) ListUser(context.Context, *ListUserReq) (*ListUserResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListUser not implemented")
}
func (UnimplementedSlurmServer) GetUser(context.Context, *GetUserReq) (*GetUserResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUser not implemented")
}
func (UnimplementedSlurmServer) UpdateUser(context.Context, *UpdateUserReq) (*UpdateUserResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateUser not implemented")
}
func (UnimplementedSlurmServer) DeleteUser(context.Context, *DeleteUserReq) (*DeleteUserResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteUser not implemented")
}
func (UnimplementedSlurmServer) ListPartition(context.Context, *ListPartitionReq) (*ListPartitionResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPartition not implemented")
}
func (UnimplementedSlurmServer) GetPartition(context.Context, *GetPartitionReq) (*GetPartitionResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPartition not implemented")
}
func (UnimplementedSlurmServer) ListNode(context.Context, *ListNodeReq) (*ListNodeResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListNode not implemented")
}
func (UnimplementedSlurmServer) GetNode(context.Context, *GetNodeReq) (*GetNodeResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNode not implemented")
}
func (UnimplementedSlurmServer) ListReservation(context.Context, *ListReservationReq) (*ListReservationResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListReservation not implemented")
}
func (UnimplementedSlurmServer) GetReservation(context.Context, *GetReservationReq) (*GetReservationResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetReservation not implemented")
}
func (UnimplementedSlurmServer) LoadConfiguration(context.Context, *LoadConfigurationReq) (*LoadConfigurationResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LoadConfiguration not implemented")
}
func (UnimplementedSlurmServer) DumpConfiguration(context.Context, *DumpConfigurationReq) (*DumpConfigurationResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DumpConfiguration not implemented")
}
func (UnimplementedSlurmServer) ListQos(context.Context, *ListQosReq) (*ListQosResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListQos not implemented")
}
func (UnimplementedSlurmServer) GetQos(context.Context, *GetQosReq) (*GetQosResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetQos not implemented")
}
func (UnimplementedSlurmServer) DeleteQos(context.Context, *DeleteQosReq) (*DeleteQosResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteQos not implemented")
}
func (UnimplementedSlurmServer) ListTres(context.Context, *ListTresReq) (*ListTresResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTres not implemented")
}
func (UnimplementedSlurmServer) SetTres(context.Context, *SetTresReq) (*SetTresResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetTres not implemented")
}
func (UnimplementedSlurmServer) ListAccount(context.Context, *ListAccountReq) (*ListAccountResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAccount not implemented")
}
func (UnimplementedSlurmServer) GetAccount(context.Context, *GetAccountReq) (*GetAccountResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAccount not implemented")
}
func (UnimplementedSlurmServer) UpdateAccount(context.Context, *UpdateAccountReq) (*UpdateAccountResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateAccount not implemented")
}
func (UnimplementedSlurmServer) DeleteAccount(context.Context, *DeleteAccountReq) (*DeleteAccountResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAccount not implemented")
}
func (UnimplementedSlurmServer) ListCluster(context.Context, *ListClusterReq) (*ListClusterResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCluster not implemented")
}
func (UnimplementedSlurmServer) GetCluster(context.Context, *GetClusterReq) (*GetClusterResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCluster not implemented")
}
func (UnimplementedSlurmServer) AddCluster(context.Context, *AddClusterReq) (*AddClusterResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddCluster not implemented")
}
func (UnimplementedSlurmServer) DeleteCluster(context.Context, *DeleteClusterReq) (*DeleteClusterResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCluster not implemented")
}
func (UnimplementedSlurmServer) ListWckey(context.Context, *ListWckeyReq) (*ListWckeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListWckey not implemented")
}
func (UnimplementedSlurmServer) GetWckey(context.Context, *GetWckeyReq) (*GetWckeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetWckey not implemented")
}
func (UnimplementedSlurmServer) AddWckey(context.Context, *AddWckeyReq) (*AddWckeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddWckey not implemented")
}
func (UnimplementedSlurmServer) DeleteWckey(context.Context, *DeleteWckeyReq) (*DeleteWckeyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteWckey not implemented")
}
func (UnimplementedSlurmServer) ListAssociation(context.Context, *ListAssociationReq) (*ListAssociationResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListAssociation not implemented")
}
func (UnimplementedSlurmServer) GetAssociation(context.Context, *GetAssociationReq) (*GetAssociationResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAssociation not implemented")
}
func (UnimplementedSlurmServer) SetAssociation(context.Context, *SetAssociationReq) (*SetAssociationResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SetAssociation not implemented")
}
func (UnimplementedSlurmServer) DeleteAssociation(context.Context, *DeleteAssociationReq) (*DeleteAssociationResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAssociation not implemented")
}
func (UnimplementedSlurmServer) GetDiagnostics(context.Context, *ListDiagnosticsReq) (*ListDiagnosticsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDiagnostics not implemented")
}
func (UnimplementedSlurmServer) GetDbDiagnostics(context.Context, *ListDbDiagnosticsReq) (*ListDbDiagnosticsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDbDiagnostics not implemented")
}
func (UnimplementedSlurmServer) mustEmbedUnimplementedSlurmServer() {}

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

func RegisterSlurmServer(s grpc.ServiceRegistrar, srv SlurmServer) {
	s.RegisterService(&Slurm_ServiceDesc, srv)
}

func _Slurm_SyncToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SyncTokenReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).SyncToken(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/syncToken",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).SyncToken(ctx, req.(*SyncTokenReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).Ping(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/ping",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).Ping(ctx, req.(*PingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListJobReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListJob(ctx, req.(*ListJobReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetJobReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetJob(ctx, req.(*GetJobReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_UpdateJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateJobReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).UpdateJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/updateJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).UpdateJob(ctx, req.(*UpdateJobReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_CancelJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelJobReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).CancelJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/cancelJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).CancelJob(ctx, req.(*CancelJobReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_SubmitJob_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SubmitJobReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).SubmitJob(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/submitJob",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).SubmitJob(ctx, req.(*SubmitJobReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListUserReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListUser(ctx, req.(*ListUserReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetUserReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetUser(ctx, req.(*GetUserReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_UpdateUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateUserReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).UpdateUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/updateUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).UpdateUser(ctx, req.(*UpdateUserReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_DeleteUser_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteUserReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).DeleteUser(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/deleteUser",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).DeleteUser(ctx, req.(*DeleteUserReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListPartition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListPartitionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListPartition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listPartition",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListPartition(ctx, req.(*ListPartitionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetPartition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPartitionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetPartition(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getPartition",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetPartition(ctx, req.(*GetPartitionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListNodeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListNode(ctx, req.(*ListNodeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetNodeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetNode(ctx, req.(*GetNodeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListReservation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListReservationReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListReservation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listReservation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListReservation(ctx, req.(*ListReservationReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetReservation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetReservationReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetReservation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getReservation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetReservation(ctx, req.(*GetReservationReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_LoadConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadConfigurationReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).LoadConfiguration(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/loadConfiguration",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).LoadConfiguration(ctx, req.(*LoadConfigurationReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_DumpConfiguration_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DumpConfigurationReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).DumpConfiguration(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/dumpConfiguration",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).DumpConfiguration(ctx, req.(*DumpConfigurationReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListQos_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListQosReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListQos(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listQos",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListQos(ctx, req.(*ListQosReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetQos_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetQosReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetQos(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getQos",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetQos(ctx, req.(*GetQosReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_DeleteQos_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteQosReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).DeleteQos(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/deleteQos",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).DeleteQos(ctx, req.(*DeleteQosReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListTres_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTresReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListTres(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listTres",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListTres(ctx, req.(*ListTresReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_SetTres_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetTresReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).SetTres(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/setTres",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).SetTres(ctx, req.(*SetTresReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAccountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListAccount(ctx, req.(*ListAccountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAccountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetAccount(ctx, req.(*GetAccountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_UpdateAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateAccountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).UpdateAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/updateAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).UpdateAccount(ctx, req.(*UpdateAccountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_DeleteAccount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAccountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).DeleteAccount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/deleteAccount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).DeleteAccount(ctx, req.(*DeleteAccountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListCluster(ctx, req.(*ListClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetCluster(ctx, req.(*GetClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_AddCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).AddCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/addCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).AddCluster(ctx, req.(*AddClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_DeleteCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).DeleteCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/deleteCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).DeleteCluster(ctx, req.(*DeleteClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListWckey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListWckeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListWckey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listWckey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListWckey(ctx, req.(*ListWckeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetWckey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetWckeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetWckey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getWckey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetWckey(ctx, req.(*GetWckeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_AddWckey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AddWckeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).AddWckey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/addWckey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).AddWckey(ctx, req.(*AddWckeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_DeleteWckey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteWckeyReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).DeleteWckey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/deleteWckey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).DeleteWckey(ctx, req.(*DeleteWckeyReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_ListAssociation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListAssociationReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).ListAssociation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/listAssociation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).ListAssociation(ctx, req.(*ListAssociationReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetAssociation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetAssociationReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetAssociation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getAssociation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetAssociation(ctx, req.(*GetAssociationReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_SetAssociation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(SetAssociationReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).SetAssociation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/setAssociation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).SetAssociation(ctx, req.(*SetAssociationReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_DeleteAssociation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAssociationReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).DeleteAssociation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/deleteAssociation",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).DeleteAssociation(ctx, req.(*DeleteAssociationReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetDiagnostics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDiagnosticsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetDiagnostics(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getDiagnostics",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetDiagnostics(ctx, req.(*ListDiagnosticsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _Slurm_GetDbDiagnostics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDbDiagnosticsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SlurmServer).GetDbDiagnostics(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/slurm.slurm/getDbDiagnostics",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SlurmServer).GetDbDiagnostics(ctx, req.(*ListDbDiagnosticsReq))
	}
	return interceptor(ctx, in, info, handler)
}

// Slurm_ServiceDesc is the grpc.ServiceDesc for Slurm service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Slurm_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "slurm.slurm",
	HandlerType: (*SlurmServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "syncToken",
			Handler:    _Slurm_SyncToken_Handler,
		},
		{
			MethodName: "ping",
			Handler:    _Slurm_Ping_Handler,
		},
		{
			MethodName: "listJob",
			Handler:    _Slurm_ListJob_Handler,
		},
		{
			MethodName: "getJob",
			Handler:    _Slurm_GetJob_Handler,
		},
		{
			MethodName: "updateJob",
			Handler:    _Slurm_UpdateJob_Handler,
		},
		{
			MethodName: "cancelJob",
			Handler:    _Slurm_CancelJob_Handler,
		},
		{
			MethodName: "submitJob",
			Handler:    _Slurm_SubmitJob_Handler,
		},
		{
			MethodName: "listUser",
			Handler:    _Slurm_ListUser_Handler,
		},
		{
			MethodName: "getUser",
			Handler:    _Slurm_GetUser_Handler,
		},
		{
			MethodName: "updateUser",
			Handler:    _Slurm_UpdateUser_Handler,
		},
		{
			MethodName: "deleteUser",
			Handler:    _Slurm_DeleteUser_Handler,
		},
		{
			MethodName: "listPartition",
			Handler:    _Slurm_ListPartition_Handler,
		},
		{
			MethodName: "getPartition",
			Handler:    _Slurm_GetPartition_Handler,
		},
		{
			MethodName: "listNode",
			Handler:    _Slurm_ListNode_Handler,
		},
		{
			MethodName: "getNode",
			Handler:    _Slurm_GetNode_Handler,
		},
		{
			MethodName: "listReservation",
			Handler:    _Slurm_ListReservation_Handler,
		},
		{
			MethodName: "getReservation",
			Handler:    _Slurm_GetReservation_Handler,
		},
		{
			MethodName: "loadConfiguration",
			Handler:    _Slurm_LoadConfiguration_Handler,
		},
		{
			MethodName: "dumpConfiguration",
			Handler:    _Slurm_DumpConfiguration_Handler,
		},
		{
			MethodName: "listQos",
			Handler:    _Slurm_ListQos_Handler,
		},
		{
			MethodName: "getQos",
			Handler:    _Slurm_GetQos_Handler,
		},
		{
			MethodName: "deleteQos",
			Handler:    _Slurm_DeleteQos_Handler,
		},
		{
			MethodName: "listTres",
			Handler:    _Slurm_ListTres_Handler,
		},
		{
			MethodName: "setTres",
			Handler:    _Slurm_SetTres_Handler,
		},
		{
			MethodName: "listAccount",
			Handler:    _Slurm_ListAccount_Handler,
		},
		{
			MethodName: "getAccount",
			Handler:    _Slurm_GetAccount_Handler,
		},
		{
			MethodName: "updateAccount",
			Handler:    _Slurm_UpdateAccount_Handler,
		},
		{
			MethodName: "deleteAccount",
			Handler:    _Slurm_DeleteAccount_Handler,
		},
		{
			MethodName: "listCluster",
			Handler:    _Slurm_ListCluster_Handler,
		},
		{
			MethodName: "getCluster",
			Handler:    _Slurm_GetCluster_Handler,
		},
		{
			MethodName: "addCluster",
			Handler:    _Slurm_AddCluster_Handler,
		},
		{
			MethodName: "deleteCluster",
			Handler:    _Slurm_DeleteCluster_Handler,
		},
		{
			MethodName: "listWckey",
			Handler:    _Slurm_ListWckey_Handler,
		},
		{
			MethodName: "getWckey",
			Handler:    _Slurm_GetWckey_Handler,
		},
		{
			MethodName: "addWckey",
			Handler:    _Slurm_AddWckey_Handler,
		},
		{
			MethodName: "deleteWckey",
			Handler:    _Slurm_DeleteWckey_Handler,
		},
		{
			MethodName: "listAssociation",
			Handler:    _Slurm_ListAssociation_Handler,
		},
		{
			MethodName: "getAssociation",
			Handler:    _Slurm_GetAssociation_Handler,
		},
		{
			MethodName: "setAssociation",
			Handler:    _Slurm_SetAssociation_Handler,
		},
		{
			MethodName: "deleteAssociation",
			Handler:    _Slurm_DeleteAssociation_Handler,
		},
		{
			MethodName: "getDiagnostics",
			Handler:    _Slurm_GetDiagnostics_Handler,
		},
		{
			MethodName: "getDbDiagnostics",
			Handler:    _Slurm_GetDbDiagnostics_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "slurm.proto",
}