// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: pkg/api/job.proto

package api

import (
	context "context"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	_ "google.golang.org/genproto/googleapis/api/annotations"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type JobRunState int32

const (
	JobRunState_RUN_STATE_UNKNOWN         JobRunState = 0
	JobRunState_RUN_STATE_LEASED          JobRunState = 1
	JobRunState_RUN_STATE_PENDING         JobRunState = 2
	JobRunState_RUN_STATE_RUNNING         JobRunState = 3
	JobRunState_RUN_STATE_SUCCEEDED       JobRunState = 4
	JobRunState_RUN_STATE_FAILED          JobRunState = 5
	JobRunState_RUN_STATE_PREEMPTED       JobRunState = 6
	JobRunState_RUN_STATE_CANCELLED       JobRunState = 7
	JobRunState_RUN_STATE_LEASE_EXPIRED   JobRunState = 8
	JobRunState_RUNS_STATE_LEASE_RETURNED JobRunState = 9
)

var JobRunState_name = map[int32]string{
	0: "RUN_STATE_UNKNOWN",
	1: "RUN_STATE_LEASED",
	2: "RUN_STATE_PENDING",
	3: "RUN_STATE_RUNNING",
	4: "RUN_STATE_SUCCEEDED",
	5: "RUN_STATE_FAILED",
	6: "RUN_STATE_PREEMPTED",
	7: "RUN_STATE_CANCELLED",
	8: "RUN_STATE_LEASE_EXPIRED",
	9: "RUNS_STATE_LEASE_RETURNED",
}

var JobRunState_value = map[string]int32{
	"RUN_STATE_UNKNOWN":         0,
	"RUN_STATE_LEASED":          1,
	"RUN_STATE_PENDING":         2,
	"RUN_STATE_RUNNING":         3,
	"RUN_STATE_SUCCEEDED":       4,
	"RUN_STATE_FAILED":          5,
	"RUN_STATE_PREEMPTED":       6,
	"RUN_STATE_CANCELLED":       7,
	"RUN_STATE_LEASE_EXPIRED":   8,
	"RUNS_STATE_LEASE_RETURNED": 9,
}

func (x JobRunState) String() string {
	return proto.EnumName(JobRunState_name, int32(x))
}

func (JobRunState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{0}
}

type JobRunDetails struct {
	RunId      string           `protobuf:"bytes,1,opt,name=run_id,json=runId,proto3" json:"runId,omitempty"`
	JobId      string           `protobuf:"bytes,2,opt,name=job_id,json=jobId,proto3" json:"jobId,omitempty"`
	State      JobRunState      `protobuf:"varint,3,opt,name=state,proto3,enum=api.JobRunState" json:"state,omitempty"`
	Cluster    string           `protobuf:"bytes,4,opt,name=cluster,proto3" json:"cluster,omitempty"`
	Node       string           `protobuf:"bytes,5,opt,name=node,proto3" json:"node,omitempty"`
	LeasedTs   *types.Timestamp `protobuf:"bytes,7,opt,name=leased_ts,json=leasedTs,proto3" json:"leasedTs,omitempty"`
	PendingTs  *types.Timestamp `protobuf:"bytes,8,opt,name=pending_ts,json=pendingTs,proto3" json:"pendingTs,omitempty"`
	StartedTs  *types.Timestamp `protobuf:"bytes,9,opt,name=started_ts,json=startedTs,proto3" json:"startedTs,omitempty"`
	FinishedTs *types.Timestamp `protobuf:"bytes,10,opt,name=finished_ts,json=finishedTs,proto3" json:"finishedTs,omitempty"`
}

func (m *JobRunDetails) Reset()         { *m = JobRunDetails{} }
func (m *JobRunDetails) String() string { return proto.CompactTextString(m) }
func (*JobRunDetails) ProtoMessage()    {}
func (*JobRunDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{0}
}
func (m *JobRunDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobRunDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobRunDetails.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobRunDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobRunDetails.Merge(m, src)
}
func (m *JobRunDetails) XXX_Size() int {
	return m.Size()
}
func (m *JobRunDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_JobRunDetails.DiscardUnknown(m)
}

var xxx_messageInfo_JobRunDetails proto.InternalMessageInfo

func (m *JobRunDetails) GetRunId() string {
	if m != nil {
		return m.RunId
	}
	return ""
}

func (m *JobRunDetails) GetJobId() string {
	if m != nil {
		return m.JobId
	}
	return ""
}

func (m *JobRunDetails) GetState() JobRunState {
	if m != nil {
		return m.State
	}
	return JobRunState_RUN_STATE_UNKNOWN
}

func (m *JobRunDetails) GetCluster() string {
	if m != nil {
		return m.Cluster
	}
	return ""
}

func (m *JobRunDetails) GetNode() string {
	if m != nil {
		return m.Node
	}
	return ""
}

func (m *JobRunDetails) GetLeasedTs() *types.Timestamp {
	if m != nil {
		return m.LeasedTs
	}
	return nil
}

func (m *JobRunDetails) GetPendingTs() *types.Timestamp {
	if m != nil {
		return m.PendingTs
	}
	return nil
}

func (m *JobRunDetails) GetStartedTs() *types.Timestamp {
	if m != nil {
		return m.StartedTs
	}
	return nil
}

func (m *JobRunDetails) GetFinishedTs() *types.Timestamp {
	if m != nil {
		return m.FinishedTs
	}
	return nil
}

type JobDetails struct {
	JobId            string           `protobuf:"bytes,1,opt,name=job_id,json=jobId,proto3" json:"jobId,omitempty"`
	Queue            string           `protobuf:"bytes,2,opt,name=queue,proto3" json:"queue,omitempty"`
	Jobset           string           `protobuf:"bytes,3,opt,name=jobset,proto3" json:"jobset,omitempty"`
	Namespace        string           `protobuf:"bytes,4,opt,name=namespace,proto3" json:"namespace,omitempty"`
	State            JobState         `protobuf:"varint,5,opt,name=state,proto3,enum=api.JobState" json:"state,omitempty"`
	SubmittedTs      *types.Timestamp `protobuf:"bytes,6,opt,name=submitted_ts,json=submittedTs,proto3" json:"submittedTs,omitempty"`
	CancelTs         *types.Timestamp `protobuf:"bytes,7,opt,name=cancel_ts,json=cancelTs,proto3" json:"cancelTs,omitempty"`
	CancelReason     string           `protobuf:"bytes,8,opt,name=cancel_reason,json=cancelReason,proto3" json:"cancelReason,omitempty"`
	LastTransitionTs *types.Timestamp `protobuf:"bytes,9,opt,name=last_transition_ts,json=lastTransitionTs,proto3" json:"lastTransitionTs,omitempty"`
	LatestRunId      string           `protobuf:"bytes,10,opt,name=latest_run_id,json=latestRunId,proto3" json:"latestRunId,omitempty"`
	JobSpec          *Job             `protobuf:"bytes,11,opt,name=job_spec,json=jobSpec,proto3" json:"jobSpec,omitempty"`
	JobRuns          []*JobRunDetails `protobuf:"bytes,12,rep,name=job_runs,json=jobRuns,proto3" json:"jobRuns,omitempty"`
	CancelUser       string           `protobuf:"bytes,13,opt,name=cancel_user,json=cancelUser,proto3" json:"cancelUser,omitempty"`
}

func (m *JobDetails) Reset()         { *m = JobDetails{} }
func (m *JobDetails) String() string { return proto.CompactTextString(m) }
func (*JobDetails) ProtoMessage()    {}
func (*JobDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{1}
}
func (m *JobDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobDetails.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobDetails.Merge(m, src)
}
func (m *JobDetails) XXX_Size() int {
	return m.Size()
}
func (m *JobDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_JobDetails.DiscardUnknown(m)
}

var xxx_messageInfo_JobDetails proto.InternalMessageInfo

func (m *JobDetails) GetJobId() string {
	if m != nil {
		return m.JobId
	}
	return ""
}

func (m *JobDetails) GetQueue() string {
	if m != nil {
		return m.Queue
	}
	return ""
}

func (m *JobDetails) GetJobset() string {
	if m != nil {
		return m.Jobset
	}
	return ""
}

func (m *JobDetails) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *JobDetails) GetState() JobState {
	if m != nil {
		return m.State
	}
	return JobState_QUEUED
}

func (m *JobDetails) GetSubmittedTs() *types.Timestamp {
	if m != nil {
		return m.SubmittedTs
	}
	return nil
}

func (m *JobDetails) GetCancelTs() *types.Timestamp {
	if m != nil {
		return m.CancelTs
	}
	return nil
}

func (m *JobDetails) GetCancelReason() string {
	if m != nil {
		return m.CancelReason
	}
	return ""
}

func (m *JobDetails) GetLastTransitionTs() *types.Timestamp {
	if m != nil {
		return m.LastTransitionTs
	}
	return nil
}

func (m *JobDetails) GetLatestRunId() string {
	if m != nil {
		return m.LatestRunId
	}
	return ""
}

func (m *JobDetails) GetJobSpec() *Job {
	if m != nil {
		return m.JobSpec
	}
	return nil
}

func (m *JobDetails) GetJobRuns() []*JobRunDetails {
	if m != nil {
		return m.JobRuns
	}
	return nil
}

func (m *JobDetails) GetCancelUser() string {
	if m != nil {
		return m.CancelUser
	}
	return ""
}

type JobDetailsRequest struct {
	JobIds        []string `protobuf:"bytes,1,rep,name=job_ids,json=jobIds,proto3" json:"jobIds,omitempty"`
	ExpandJobSpec bool     `protobuf:"varint,2,opt,name=expand_job_spec,json=expandJobSpec,proto3" json:"expandJobSpec,omitempty"`
	ExpandJobRun  bool     `protobuf:"varint,3,opt,name=expand_job_run,json=expandJobRun,proto3" json:"expandJobRun,omitempty"`
}

func (m *JobDetailsRequest) Reset()         { *m = JobDetailsRequest{} }
func (m *JobDetailsRequest) String() string { return proto.CompactTextString(m) }
func (*JobDetailsRequest) ProtoMessage()    {}
func (*JobDetailsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{2}
}
func (m *JobDetailsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobDetailsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobDetailsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobDetailsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobDetailsRequest.Merge(m, src)
}
func (m *JobDetailsRequest) XXX_Size() int {
	return m.Size()
}
func (m *JobDetailsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_JobDetailsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_JobDetailsRequest proto.InternalMessageInfo

func (m *JobDetailsRequest) GetJobIds() []string {
	if m != nil {
		return m.JobIds
	}
	return nil
}

func (m *JobDetailsRequest) GetExpandJobSpec() bool {
	if m != nil {
		return m.ExpandJobSpec
	}
	return false
}

func (m *JobDetailsRequest) GetExpandJobRun() bool {
	if m != nil {
		return m.ExpandJobRun
	}
	return false
}

type JobDetailsResponse struct {
	JobDetails map[string]*JobDetails `protobuf:"bytes,1,rep,name=job_details,json=jobDetails,proto3" json:"jobDetails,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *JobDetailsResponse) Reset()         { *m = JobDetailsResponse{} }
func (m *JobDetailsResponse) String() string { return proto.CompactTextString(m) }
func (*JobDetailsResponse) ProtoMessage()    {}
func (*JobDetailsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{3}
}
func (m *JobDetailsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobDetailsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobDetailsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobDetailsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobDetailsResponse.Merge(m, src)
}
func (m *JobDetailsResponse) XXX_Size() int {
	return m.Size()
}
func (m *JobDetailsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_JobDetailsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_JobDetailsResponse proto.InternalMessageInfo

func (m *JobDetailsResponse) GetJobDetails() map[string]*JobDetails {
	if m != nil {
		return m.JobDetails
	}
	return nil
}

type JobRunDetailsResponse struct {
	JobRunDetails map[string]*JobRunDetails `protobuf:"bytes,1,rep,name=job_run_details,json=jobRunDetails,proto3" json:"jobRunDetails,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *JobRunDetailsResponse) Reset()         { *m = JobRunDetailsResponse{} }
func (m *JobRunDetailsResponse) String() string { return proto.CompactTextString(m) }
func (*JobRunDetailsResponse) ProtoMessage()    {}
func (*JobRunDetailsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{4}
}
func (m *JobRunDetailsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobRunDetailsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobRunDetailsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobRunDetailsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobRunDetailsResponse.Merge(m, src)
}
func (m *JobRunDetailsResponse) XXX_Size() int {
	return m.Size()
}
func (m *JobRunDetailsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_JobRunDetailsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_JobRunDetailsResponse proto.InternalMessageInfo

func (m *JobRunDetailsResponse) GetJobRunDetails() map[string]*JobRunDetails {
	if m != nil {
		return m.JobRunDetails
	}
	return nil
}

type JobRunDetailsRequest struct {
	RunIds []string `protobuf:"bytes,1,rep,name=run_ids,json=runIds,proto3" json:"runIds,omitempty"`
}

func (m *JobRunDetailsRequest) Reset()         { *m = JobRunDetailsRequest{} }
func (m *JobRunDetailsRequest) String() string { return proto.CompactTextString(m) }
func (*JobRunDetailsRequest) ProtoMessage()    {}
func (*JobRunDetailsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{5}
}
func (m *JobRunDetailsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobRunDetailsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobRunDetailsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobRunDetailsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobRunDetailsRequest.Merge(m, src)
}
func (m *JobRunDetailsRequest) XXX_Size() int {
	return m.Size()
}
func (m *JobRunDetailsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_JobRunDetailsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_JobRunDetailsRequest proto.InternalMessageInfo

func (m *JobRunDetailsRequest) GetRunIds() []string {
	if m != nil {
		return m.RunIds
	}
	return nil
}

type JobErrorsRequest struct {
	JobIds []string `protobuf:"bytes,1,rep,name=job_ids,json=jobIds,proto3" json:"jobIds,omitempty"`
}

func (m *JobErrorsRequest) Reset()         { *m = JobErrorsRequest{} }
func (m *JobErrorsRequest) String() string { return proto.CompactTextString(m) }
func (*JobErrorsRequest) ProtoMessage()    {}
func (*JobErrorsRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{6}
}
func (m *JobErrorsRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobErrorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobErrorsRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobErrorsRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobErrorsRequest.Merge(m, src)
}
func (m *JobErrorsRequest) XXX_Size() int {
	return m.Size()
}
func (m *JobErrorsRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_JobErrorsRequest.DiscardUnknown(m)
}

var xxx_messageInfo_JobErrorsRequest proto.InternalMessageInfo

func (m *JobErrorsRequest) GetJobIds() []string {
	if m != nil {
		return m.JobIds
	}
	return nil
}

type JobErrorsResponse struct {
	JobErrors map[string]string `protobuf:"bytes,1,rep,name=job_errors,json=jobErrors,proto3" json:"jobErrors,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *JobErrorsResponse) Reset()         { *m = JobErrorsResponse{} }
func (m *JobErrorsResponse) String() string { return proto.CompactTextString(m) }
func (*JobErrorsResponse) ProtoMessage()    {}
func (*JobErrorsResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{7}
}
func (m *JobErrorsResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobErrorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobErrorsResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobErrorsResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobErrorsResponse.Merge(m, src)
}
func (m *JobErrorsResponse) XXX_Size() int {
	return m.Size()
}
func (m *JobErrorsResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_JobErrorsResponse.DiscardUnknown(m)
}

var xxx_messageInfo_JobErrorsResponse proto.InternalMessageInfo

func (m *JobErrorsResponse) GetJobErrors() map[string]string {
	if m != nil {
		return m.JobErrors
	}
	return nil
}

type JobStatusRequest struct {
	JobIds []string `protobuf:"bytes,1,rep,name=job_ids,json=jobIds,proto3" json:"jobIds,omitempty"`
}

func (m *JobStatusRequest) Reset()         { *m = JobStatusRequest{} }
func (m *JobStatusRequest) String() string { return proto.CompactTextString(m) }
func (*JobStatusRequest) ProtoMessage()    {}
func (*JobStatusRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{8}
}
func (m *JobStatusRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobStatusRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobStatusRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobStatusRequest.Merge(m, src)
}
func (m *JobStatusRequest) XXX_Size() int {
	return m.Size()
}
func (m *JobStatusRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_JobStatusRequest.DiscardUnknown(m)
}

var xxx_messageInfo_JobStatusRequest proto.InternalMessageInfo

func (m *JobStatusRequest) GetJobIds() []string {
	if m != nil {
		return m.JobIds
	}
	return nil
}

type ActiveQueues struct {
	Queues []string `protobuf:"bytes,1,rep,name=queues,proto3" json:"queues,omitempty"`
}

func (m *ActiveQueues) Reset()         { *m = ActiveQueues{} }
func (m *ActiveQueues) String() string { return proto.CompactTextString(m) }
func (*ActiveQueues) ProtoMessage()    {}
func (*ActiveQueues) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{9}
}
func (m *ActiveQueues) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ActiveQueues) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ActiveQueues.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ActiveQueues) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ActiveQueues.Merge(m, src)
}
func (m *ActiveQueues) XXX_Size() int {
	return m.Size()
}
func (m *ActiveQueues) XXX_DiscardUnknown() {
	xxx_messageInfo_ActiveQueues.DiscardUnknown(m)
}

var xxx_messageInfo_ActiveQueues proto.InternalMessageInfo

func (m *ActiveQueues) GetQueues() []string {
	if m != nil {
		return m.Queues
	}
	return nil
}

type GetActiveQueuesRequest struct {
}

func (m *GetActiveQueuesRequest) Reset()         { *m = GetActiveQueuesRequest{} }
func (m *GetActiveQueuesRequest) String() string { return proto.CompactTextString(m) }
func (*GetActiveQueuesRequest) ProtoMessage()    {}
func (*GetActiveQueuesRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{10}
}
func (m *GetActiveQueuesRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetActiveQueuesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetActiveQueuesRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetActiveQueuesRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetActiveQueuesRequest.Merge(m, src)
}
func (m *GetActiveQueuesRequest) XXX_Size() int {
	return m.Size()
}
func (m *GetActiveQueuesRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_GetActiveQueuesRequest.DiscardUnknown(m)
}

var xxx_messageInfo_GetActiveQueuesRequest proto.InternalMessageInfo

type GetActiveQueuesResponse struct {
	ActiveQueuesByPool map[string]*ActiveQueues `protobuf:"bytes,1,rep,name=active_queues_by_pool,json=activeQueuesByPool,proto3" json:"activeQueuesByPool,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *GetActiveQueuesResponse) Reset()         { *m = GetActiveQueuesResponse{} }
func (m *GetActiveQueuesResponse) String() string { return proto.CompactTextString(m) }
func (*GetActiveQueuesResponse) ProtoMessage()    {}
func (*GetActiveQueuesResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{11}
}
func (m *GetActiveQueuesResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GetActiveQueuesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GetActiveQueuesResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *GetActiveQueuesResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetActiveQueuesResponse.Merge(m, src)
}
func (m *GetActiveQueuesResponse) XXX_Size() int {
	return m.Size()
}
func (m *GetActiveQueuesResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_GetActiveQueuesResponse.DiscardUnknown(m)
}

var xxx_messageInfo_GetActiveQueuesResponse proto.InternalMessageInfo

func (m *GetActiveQueuesResponse) GetActiveQueuesByPool() map[string]*ActiveQueues {
	if m != nil {
		return m.ActiveQueuesByPool
	}
	return nil
}

type JobStatusUsingExternalJobUriRequest struct {
	Queue          string `protobuf:"bytes,1,opt,name=queue,proto3" json:"queue,omitempty"`
	Jobset         string `protobuf:"bytes,2,opt,name=jobset,proto3" json:"jobset,omitempty"`
	ExternalJobUri string `protobuf:"bytes,3,opt,name=external_job_uri,json=externalJobUri,proto3" json:"externalJobUri,omitempty"`
}

func (m *JobStatusUsingExternalJobUriRequest) Reset()         { *m = JobStatusUsingExternalJobUriRequest{} }
func (m *JobStatusUsingExternalJobUriRequest) String() string { return proto.CompactTextString(m) }
func (*JobStatusUsingExternalJobUriRequest) ProtoMessage()    {}
func (*JobStatusUsingExternalJobUriRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{12}
}
func (m *JobStatusUsingExternalJobUriRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobStatusUsingExternalJobUriRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobStatusUsingExternalJobUriRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobStatusUsingExternalJobUriRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobStatusUsingExternalJobUriRequest.Merge(m, src)
}
func (m *JobStatusUsingExternalJobUriRequest) XXX_Size() int {
	return m.Size()
}
func (m *JobStatusUsingExternalJobUriRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_JobStatusUsingExternalJobUriRequest.DiscardUnknown(m)
}

var xxx_messageInfo_JobStatusUsingExternalJobUriRequest proto.InternalMessageInfo

func (m *JobStatusUsingExternalJobUriRequest) GetQueue() string {
	if m != nil {
		return m.Queue
	}
	return ""
}

func (m *JobStatusUsingExternalJobUriRequest) GetJobset() string {
	if m != nil {
		return m.Jobset
	}
	return ""
}

func (m *JobStatusUsingExternalJobUriRequest) GetExternalJobUri() string {
	if m != nil {
		return m.ExternalJobUri
	}
	return ""
}

type JobStatusResponse struct {
	JobStates map[string]JobState `protobuf:"bytes,1,rep,name=job_states,json=jobStates,proto3" json:"jobStates,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=api.JobState"`
}

func (m *JobStatusResponse) Reset()         { *m = JobStatusResponse{} }
func (m *JobStatusResponse) String() string { return proto.CompactTextString(m) }
func (*JobStatusResponse) ProtoMessage()    {}
func (*JobStatusResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_e45f6b75bfad87a4, []int{13}
}
func (m *JobStatusResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobStatusResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *JobStatusResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobStatusResponse.Merge(m, src)
}
func (m *JobStatusResponse) XXX_Size() int {
	return m.Size()
}
func (m *JobStatusResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_JobStatusResponse.DiscardUnknown(m)
}

var xxx_messageInfo_JobStatusResponse proto.InternalMessageInfo

func (m *JobStatusResponse) GetJobStates() map[string]JobState {
	if m != nil {
		return m.JobStates
	}
	return nil
}

func init() {
	proto.RegisterEnum("api.JobRunState", JobRunState_name, JobRunState_value)
	proto.RegisterType((*JobRunDetails)(nil), "api.JobRunDetails")
	proto.RegisterType((*JobDetails)(nil), "api.JobDetails")
	proto.RegisterType((*JobDetailsRequest)(nil), "api.JobDetailsRequest")
	proto.RegisterType((*JobDetailsResponse)(nil), "api.JobDetailsResponse")
	proto.RegisterMapType((map[string]*JobDetails)(nil), "api.JobDetailsResponse.JobDetailsEntry")
	proto.RegisterType((*JobRunDetailsResponse)(nil), "api.JobRunDetailsResponse")
	proto.RegisterMapType((map[string]*JobRunDetails)(nil), "api.JobRunDetailsResponse.JobRunDetailsEntry")
	proto.RegisterType((*JobRunDetailsRequest)(nil), "api.JobRunDetailsRequest")
	proto.RegisterType((*JobErrorsRequest)(nil), "api.JobErrorsRequest")
	proto.RegisterType((*JobErrorsResponse)(nil), "api.JobErrorsResponse")
	proto.RegisterMapType((map[string]string)(nil), "api.JobErrorsResponse.JobErrorsEntry")
	proto.RegisterType((*JobStatusRequest)(nil), "api.JobStatusRequest")
	proto.RegisterType((*ActiveQueues)(nil), "api.ActiveQueues")
	proto.RegisterType((*GetActiveQueuesRequest)(nil), "api.GetActiveQueuesRequest")
	proto.RegisterType((*GetActiveQueuesResponse)(nil), "api.GetActiveQueuesResponse")
	proto.RegisterMapType((map[string]*ActiveQueues)(nil), "api.GetActiveQueuesResponse.ActiveQueuesByPoolEntry")
	proto.RegisterType((*JobStatusUsingExternalJobUriRequest)(nil), "api.JobStatusUsingExternalJobUriRequest")
	proto.RegisterType((*JobStatusResponse)(nil), "api.JobStatusResponse")
	proto.RegisterMapType((map[string]JobState)(nil), "api.JobStatusResponse.JobStatesEntry")
}

func init() { proto.RegisterFile("pkg/api/job.proto", fileDescriptor_e45f6b75bfad87a4) }

var fileDescriptor_e45f6b75bfad87a4 = []byte{
	// 1569 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x58, 0x4f, 0x6f, 0xdb, 0x46,
	0x16, 0x37, 0xe5, 0xbf, 0x7a, 0xb2, 0x6c, 0x7a, 0xfc, 0x4f, 0x56, 0xbc, 0xa6, 0x97, 0xc1, 0x26,
	0x8e, 0x91, 0x48, 0x58, 0xef, 0x2e, 0x90, 0xf5, 0x26, 0xd8, 0xda, 0x16, 0x13, 0xd8, 0x4d, 0x15,
	0x97, 0xb6, 0xd0, 0xa0, 0x68, 0x21, 0x90, 0xd2, 0xc4, 0xa1, 0x22, 0x91, 0x0c, 0x87, 0x34, 0x62,
	0xa0, 0x87, 0xa2, 0x40, 0x0f, 0xb9, 0xb5, 0xe8, 0x97, 0xe8, 0x27, 0x29, 0xda, 0x43, 0x81, 0x00,
	0xed, 0x21, 0x27, 0xa1, 0x48, 0x0a, 0x14, 0xd0, 0xa9, 0xdf, 0xa0, 0x05, 0x67, 0x48, 0x6a, 0x86,
	0xb2, 0x2b, 0x27, 0x47, 0xfd, 0xde, 0x7b, 0xbf, 0x79, 0xf3, 0xfe, 0xcd, 0xa3, 0x60, 0xce, 0x7d,
	0x7a, 0x52, 0x36, 0x5c, 0xab, 0xdc, 0x72, 0xcc, 0x92, 0xeb, 0x39, 0xbe, 0x83, 0x46, 0x0d, 0xd7,
	0x2a, 0x2e, 0xc4, 0x38, 0x09, 0xcc, 0x8e, 0xe5, 0x33, 0x51, 0x51, 0x39, 0x71, 0x9c, 0x93, 0x36,
	0x2e, 0xd3, 0x5f, 0x66, 0xf0, 0xb8, 0xec, 0x5b, 0x1d, 0x4c, 0x7c, 0xa3, 0xe3, 0x46, 0x0a, 0xab,
	0x91, 0x42, 0x68, 0x69, 0xd8, 0xb6, 0xe3, 0x1b, 0xbe, 0xe5, 0xd8, 0x84, 0x49, 0xd5, 0x1f, 0xc7,
	0x20, 0x7f, 0xe0, 0x98, 0x7a, 0x60, 0x57, 0xb0, 0x6f, 0x58, 0x6d, 0x82, 0x36, 0x61, 0xc2, 0x0b,
	0xec, 0xba, 0xd5, 0x2c, 0x48, 0xeb, 0xd2, 0x46, 0x76, 0x77, 0xbe, 0xd7, 0x55, 0x66, 0xbd, 0xc0,
	0xde, 0x6f, 0xde, 0x74, 0x3a, 0x96, 0x8f, 0x3b, 0xae, 0x7f, 0xa6, 0x8f, 0x53, 0x20, 0xd4, 0x6d,
	0x39, 0x66, 0xa8, 0x9b, 0xe9, 0xeb, 0xb6, 0x1c, 0x53, 0xd4, 0xa5, 0x00, 0xfa, 0x1f, 0x8c, 0x13,
	0xdf, 0xf0, 0x71, 0x61, 0x74, 0x5d, 0xda, 0x98, 0xd9, 0x92, 0x4b, 0x86, 0x6b, 0x95, 0xd8, 0xd1,
	0x47, 0x21, 0xce, 0x8c, 0xa9, 0x0a, 0x6f, 0x4c, 0x01, 0x54, 0x86, 0xc9, 0x46, 0x3b, 0x20, 0x3e,
	0xf6, 0x0a, 0x63, 0xf4, 0xa4, 0xc5, 0x5e, 0x57, 0x99, 0x8b, 0x20, 0x4e, 0x3d, 0xd6, 0x42, 0xd7,
	0x60, 0xcc, 0x76, 0x9a, 0xb8, 0x30, 0x4e, 0xb5, 0x51, 0xaf, 0xab, 0xcc, 0x84, 0xbf, 0x39, 0x55,
	0x2a, 0x47, 0x0f, 0x21, 0xdb, 0xc6, 0x06, 0xc1, 0xcd, 0xba, 0x4f, 0x0a, 0x93, 0xeb, 0xd2, 0x46,
	0x6e, 0xab, 0x58, 0x62, 0x11, 0x2b, 0xc5, 0x21, 0x2d, 0x1d, 0xc7, 0x21, 0xdd, 0x5d, 0xea, 0x75,
	0x15, 0xc4, 0x0c, 0x8e, 0x09, 0x47, 0x36, 0x15, 0x63, 0x48, 0x07, 0x70, 0xb1, 0xdd, 0xb4, 0xec,
	0x93, 0x90, 0x71, 0x6a, 0x28, 0xe3, 0x72, 0xaf, 0xab, 0xcc, 0x47, 0x16, 0x02, 0x65, 0x36, 0x01,
	0x43, 0x4e, 0xe2, 0x1b, 0x9e, 0xcf, 0xbc, 0xcc, 0x5e, 0x8e, 0x33, 0xb2, 0x10, 0x39, 0x13, 0x10,
	0xd5, 0x20, 0xf7, 0xd8, 0xb2, 0x2d, 0xf2, 0x84, 0x91, 0xc2, 0x50, 0xd2, 0x42, 0xaf, 0xab, 0x2c,
	0xc4, 0x26, 0x02, 0x2b, 0xf4, 0x51, 0xf5, 0xe7, 0x09, 0x80, 0x03, 0xc7, 0xe4, 0x8a, 0x29, 0x2a,
	0x10, 0x69, 0x68, 0x81, 0xdc, 0x80, 0xf1, 0x67, 0x01, 0x0e, 0x30, 0x5f, 0x4b, 0x14, 0xe0, 0x55,
	0x29, 0x80, 0x6e, 0x52, 0x5a, 0x82, 0x7d, 0x5a, 0x4c, 0xd9, 0xdd, 0x85, 0x5e, 0x57, 0x91, 0x19,
	0xc2, 0x29, 0x47, 0x3a, 0xe8, 0x3f, 0x90, 0xb5, 0x8d, 0x0e, 0x26, 0xae, 0xd1, 0xc0, 0x51, 0xf9,
	0xd0, 0x08, 0x25, 0x20, 0x1f, 0xa1, 0x04, 0x44, 0xb7, 0xe3, 0x82, 0x1d, 0xa7, 0x05, 0x9b, 0x8f,
	0x0b, 0x76, 0x78, 0xb5, 0x3e, 0x82, 0x69, 0xd6, 0xa3, 0x51, 0xc6, 0x26, 0x86, 0x06, 0x77, 0xa5,
	0xd7, 0x55, 0x16, 0x13, 0x1b, 0x21, 0xba, 0x39, 0x0e, 0x0e, 0xcb, 0xb5, 0x61, 0xd8, 0x0d, 0xdc,
	0x7e, 0x8b, 0x72, 0x65, 0x06, 0x62, 0xb9, 0xc6, 0x18, 0xfa, 0x3f, 0xe4, 0x23, 0x42, 0x0f, 0x1b,
	0xc4, 0xb1, 0x69, 0xc5, 0x66, 0x77, 0x8b, 0xbd, 0xae, 0xb2, 0xc4, 0x04, 0x3a, 0xc5, 0x39, 0xe3,
	0x69, 0x1e, 0x47, 0x4f, 0x00, 0xb5, 0x0d, 0xe2, 0xd7, 0x7d, 0xcf, 0xb0, 0x89, 0x15, 0x8e, 0x96,
	0xcb, 0xd5, 0xe8, 0x5a, 0xaf, 0xab, 0x14, 0x43, 0xcb, 0xe3, 0xc4, 0x50, 0x70, 0x51, 0x4e, 0xcb,
	0xd0, 0x5d, 0xc8, 0xb7, 0x0d, 0x1f, 0x13, 0xbf, 0x1e, 0xcd, 0x27, 0xa0, 0xae, 0xd2, 0xd0, 0x31,
	0x81, 0x9e, 0x9a, 0x52, 0x39, 0x0e, 0x46, 0xdb, 0x30, 0x15, 0x96, 0x22, 0x71, 0x71, 0xa3, 0x90,
	0xa3, 0xee, 0x4d, 0xc5, 0x19, 0x65, 0xd3, 0xa4, 0xe5, 0x98, 0x47, 0x2e, 0x6e, 0xf0, 0xd3, 0x24,
	0x82, 0x50, 0x85, 0xd9, 0x7a, 0x81, 0x4d, 0x0a, 0xd3, 0xeb, 0xa3, 0x1b, 0xb9, 0x2d, 0xc4, 0x8d,
	0xaf, 0xa8, 0xd8, 0x13, 0x16, 0x3d, 0xb0, 0x49, 0x8a, 0x25, 0x84, 0xd0, 0x7f, 0x21, 0x17, 0xc5,
	0x3a, 0x20, 0xd8, 0x2b, 0xe4, 0xa9, 0xfb, 0xb4, 0xad, 0x18, 0x5c, 0x23, 0xc2, 0x2c, 0x83, 0x3e,
	0xaa, 0xfe, 0x20, 0xc1, 0x5c, 0xbf, 0xad, 0x74, 0xfc, 0x2c, 0xc0, 0xc4, 0x47, 0xb7, 0x60, 0x92,
	0x75, 0x17, 0x29, 0x48, 0xeb, 0xa3, 0x5c, 0x1f, 0xec, 0x37, 0x49, 0xaa, 0x0f, 0xf6, 0x9b, 0x04,
	0xed, 0xc1, 0x2c, 0x7e, 0xee, 0x1a, 0x76, 0xb3, 0x9e, 0x04, 0x22, 0x6c, 0xb5, 0xa9, 0xdd, 0x2b,
	0xbd, 0xae, 0xb2, 0xcc, 0x44, 0x07, 0x03, 0x41, 0xc8, 0x0b, 0x02, 0xf4, 0x1e, 0xcc, 0x70, 0x24,
	0x5e, 0x60, 0xd3, 0x16, 0x9c, 0x62, 0x15, 0x93, 0xa8, 0xea, 0x81, 0x50, 0x31, 0x3c, 0xae, 0xfe,
	0x2e, 0x01, 0xe2, 0xef, 0x42, 0x5c, 0xc7, 0x26, 0x18, 0x99, 0x90, 0x0b, 0x19, 0x9b, 0x0c, 0xa6,
	0x17, 0xca, 0x6d, 0x5d, 0x8f, 0xc3, 0x9c, 0xd2, 0xe6, 0x20, 0xcd, 0xf6, 0xbd, 0x33, 0x16, 0xc6,
	0x56, 0x02, 0xf2, 0x61, 0xec, 0xa3, 0xc5, 0x53, 0x98, 0x4d, 0x19, 0xa2, 0xab, 0x30, 0xfa, 0x14,
	0x9f, 0x45, 0xe3, 0x69, 0xae, 0xd7, 0x55, 0xf2, 0x4f, 0xf1, 0x19, 0x67, 0x1e, 0x4a, 0xd1, 0x36,
	0x8c, 0x9f, 0x1a, 0xed, 0x68, 0x34, 0xe5, 0xb6, 0x66, 0x53, 0x5e, 0xb1, 0x61, 0x40, 0x35, 0xf8,
	0x61, 0x40, 0x81, 0xed, 0xcc, 0x6d, 0x49, 0x7d, 0x91, 0x81, 0x45, 0xa1, 0x56, 0x92, 0x5b, 0x7b,
	0x30, 0x1b, 0xc5, 0x31, 0x75, 0xf3, 0x5b, 0x83, 0x05, 0xc6, 0x5f, 0xbe, 0x8f, 0xb2, 0xfb, 0xd3,
	0x14, 0xb6, 0x78, 0x9c, 0x4f, 0xa1, 0x20, 0x28, 0x7e, 0x46, 0xe3, 0x9f, 0x62, 0xb8, 0x5c, 0x20,
	0xee, 0x8a, 0x81, 0x38, 0xaf, 0x0b, 0x86, 0xc5, 0x42, 0x83, 0x85, 0xd4, 0xad, 0x92, 0x62, 0x66,
	0x7d, 0x2d, 0x14, 0x33, 0xdd, 0x33, 0x84, 0x62, 0x66, 0x88, 0xba, 0x03, 0xf2, 0x81, 0x63, 0x6a,
	0x9e, 0xe7, 0x78, 0xef, 0xd8, 0x0f, 0xea, 0x2b, 0xd6, 0x54, 0x31, 0x47, 0x94, 0x91, 0x4f, 0x21,
	0xac, 0x98, 0x3a, 0xa6, 0x68, 0x94, 0x8c, 0x7f, 0xc4, 0xf7, 0x14, 0x75, 0xfb, 0x08, 0x4b, 0x02,
	0x7d, 0x55, 0x5a, 0x31, 0xc6, 0xbf, 0x2a, 0x09, 0x58, 0x6c, 0xc2, 0x8c, 0x68, 0x75, 0xb9, 0xc0,
	0xdf, 0xe0, 0x03, 0x9f, 0x1d, 0x1a, 0x64, 0x16, 0x9d, 0xf0, 0xa5, 0x0a, 0xde, 0x35, 0x3a, 0x77,
	0x60, 0x7a, 0xa7, 0xe1, 0x5b, 0xa7, 0xf8, 0xc3, 0xf0, 0xc9, 0x25, 0xe1, 0x9b, 0x4b, 0x1f, 0x5f,
	0xc1, 0x9a, 0x21, 0xbc, 0x35, 0x43, 0xd4, 0x02, 0x2c, 0xdd, 0xc7, 0x3e, 0x4f, 0x10, 0xb9, 0xa1,
	0x7e, 0x9b, 0x81, 0xe5, 0x01, 0x51, 0x14, 0xfb, 0x17, 0x12, 0x2c, 0x1a, 0x54, 0x50, 0x67, 0x3c,
	0x75, 0xf3, 0xac, 0xee, 0x3a, 0x4e, 0x3b, 0xca, 0xc3, 0xbf, 0x69, 0x1e, 0x2e, 0xb0, 0x2e, 0xf1,
	0xe0, 0xee, 0xd9, 0xa1, 0xe3, 0xb4, 0x59, 0x5a, 0xd6, 0x7b, 0x5d, 0x65, 0xd5, 0x18, 0x10, 0x72,
	0x5e, 0xa3, 0x41, 0x69, 0xf1, 0x73, 0x09, 0x96, 0x2f, 0x60, 0xbc, 0x5c, 0xca, 0xee, 0x88, 0xbd,
	0x32, 0x47, 0x7d, 0x17, 0x18, 0x87, 0x65, 0xf1, 0x3b, 0x09, 0xae, 0x26, 0x69, 0xac, 0x11, 0xcb,
	0x3e, 0xd1, 0x9e, 0xfb, 0xd8, 0xb3, 0x8d, 0xf6, 0x81, 0x63, 0xd6, 0x3c, 0x2b, 0xce, 0x6c, 0xb2,
	0x39, 0x49, 0x6f, 0xb1, 0x39, 0x65, 0x2e, 0xb1, 0x39, 0xdd, 0x03, 0x19, 0x47, 0x27, 0xd2, 0x71,
	0x1f, 0x78, 0x56, 0xb4, 0x71, 0xad, 0xf6, 0xba, 0x4a, 0x01, 0x0b, 0xde, 0x70, 0xf6, 0x33, 0xa2,
	0x44, 0xfd, 0x8d, 0x75, 0x5a, 0x5c, 0x8f, 0x62, 0xa7, 0xd1, 0x9d, 0x69, 0xa0, 0xd3, 0x44, 0xdd,
	0x64, 0xef, 0x4a, 0x75, 0x1a, 0xc3, 0x52, 0x9d, 0xc6, 0xc0, 0x22, 0xa1, 0x9d, 0xc6, 0x59, 0x5d,
	0x2e, 0x6d, 0xb7, 0xf9, 0xb4, 0x9d, 0xbf, 0xf6, 0x5d, 0x9c, 0xb2, 0xcd, 0x2f, 0x33, 0x90, 0xe3,
	0x3e, 0x6a, 0xd0, 0x22, 0xcc, 0xe9, 0xb5, 0x6a, 0xfd, 0xe8, 0x78, 0xe7, 0x58, 0xab, 0xd7, 0xaa,
	0xef, 0x57, 0x1f, 0x7e, 0x54, 0x95, 0x47, 0xd0, 0x02, 0xc8, 0x7d, 0xf8, 0x81, 0xb6, 0x73, 0xa4,
	0x55, 0x64, 0x49, 0x54, 0x3e, 0xd4, 0xaa, 0x95, 0xfd, 0xea, 0x7d, 0x39, 0x23, 0xc2, 0x7a, 0xad,
	0x5a, 0x0d, 0xe1, 0x51, 0xb4, 0x0c, 0xf3, 0x7d, 0xf8, 0xa8, 0xb6, 0xb7, 0xa7, 0x69, 0x15, 0xad,
	0x22, 0x8f, 0x89, 0xe4, 0xf7, 0x76, 0xf6, 0x1f, 0x68, 0x15, 0x79, 0x5c, 0x54, 0x3f, 0xd4, 0x35,
	0xed, 0x83, 0xc3, 0x63, 0xad, 0x22, 0x4f, 0x88, 0x82, 0xbd, 0x9d, 0xea, 0x9e, 0xf6, 0x20, 0xb4,
	0x98, 0x44, 0x57, 0x60, 0x39, 0xe5, 0x64, 0x5d, 0x7b, 0x74, 0xb8, 0xaf, 0x6b, 0x15, 0x79, 0x0a,
	0xfd, 0x0d, 0x56, 0xf4, 0x5a, 0xf5, 0x48, 0x90, 0xea, 0xda, 0x71, 0x4d, 0xaf, 0x6a, 0x15, 0x39,
	0xbb, 0xf5, 0xc7, 0x18, 0x8c, 0x1d, 0x38, 0x26, 0x09, 0x77, 0xe1, 0xfb, 0xd8, 0x4f, 0x12, 0x8a,
	0x16, 0xd3, 0x09, 0xa6, 0x25, 0x5c, 0x5c, 0x3a, 0x3f, 0xef, 0xea, 0xca, 0x17, 0x3f, 0xfd, 0xfa,
	0x4d, 0x66, 0x5e, 0x9d, 0x29, 0x9f, 0xfe, 0x33, 0xfc, 0x20, 0x2e, 0x13, 0x2a, 0xdf, 0x96, 0x36,
	0xd1, 0xd7, 0x12, 0x28, 0x3c, 0xf5, 0x39, 0x0d, 0x82, 0x36, 0x44, 0xda, 0x8b, 0x7b, 0xe8, 0x42,
	0x07, 0x6e, 0x52, 0x07, 0xae, 0xa9, 0x7f, 0x17, 0x1d, 0x38, 0x87, 0x29, 0xf4, 0xe9, 0x13, 0xc8,
	0x33, 0x97, 0xe2, 0x0f, 0xa0, 0xa5, 0x81, 0x05, 0x86, 0x1d, 0xb7, 0x7c, 0xc1, 0x62, 0xa3, 0x16,
	0xe9, 0x79, 0x0b, 0xea, 0x6c, 0x7c, 0x5e, 0xb4, 0x16, 0x84, 0xec, 0x49, 0x2c, 0xd9, 0xf3, 0xd1,
	0x8f, 0xa5, 0xf0, 0x0c, 0xf6, 0xaf, 0x22, 0xbe, 0x56, 0x83, 0xb1, 0x64, 0x6f, 0x5c, 0xc8, 0x8c,
	0x41, 0x66, 0xcc, 0xdc, 0x1f, 0x01, 0x2b, 0xe7, 0x6d, 0x20, 0xec, 0x84, 0xe2, 0xc5, 0xcb, 0x89,
	0x78, 0x01, 0x2f, 0xb0, 0xf9, 0x0b, 0xb4, 0x60, 0x36, 0x35, 0xbc, 0xd1, 0x95, 0xf3, 0x47, 0x3a,
	0x3b, 0x67, 0xf5, 0xaf, 0xe6, 0xbd, 0xba, 0x4a, 0x4f, 0x5a, 0x52, 0xe7, 0xc2, 0x93, 0xd8, 0x7b,
	0x51, 0x66, 0x83, 0x7c, 0x5b, 0xda, 0xdc, 0xdd, 0xf9, 0xfe, 0xf5, 0x9a, 0xf4, 0xf2, 0xf5, 0x9a,
	0xf4, 0xcb, 0xeb, 0x35, 0xe9, 0xab, 0x37, 0x6b, 0x23, 0x2f, 0xdf, 0xac, 0x8d, 0xbc, 0x7a, 0xb3,
	0x36, 0xf2, 0xf1, 0xf5, 0x13, 0xcb, 0x7f, 0x12, 0x98, 0xa5, 0x86, 0xd3, 0x29, 0x1b, 0x5e, 0xc7,
	0x68, 0x1a, 0xae, 0xe7, 0xb4, 0x70, 0xc3, 0x8f, 0x7e, 0x95, 0xa3, 0x3f, 0x5a, 0xcc, 0x09, 0xfa,
	0xdd, 0xf2, 0xaf, 0x3f, 0x03, 0x00, 0x00, 0xff, 0xff, 0xf8, 0xf8, 0xa4, 0x20, 0x92, 0x11, 0x00,
	0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// JobsClient is the client API for Jobs service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type JobsClient interface {
	GetJobStatus(ctx context.Context, in *JobStatusRequest, opts ...grpc.CallOption) (*JobStatusResponse, error)
	GetJobStatusUsingExternalJobUri(ctx context.Context, in *JobStatusUsingExternalJobUriRequest, opts ...grpc.CallOption) (*JobStatusResponse, error)
	GetJobDetails(ctx context.Context, in *JobDetailsRequest, opts ...grpc.CallOption) (*JobDetailsResponse, error)
	GetJobErrors(ctx context.Context, in *JobErrorsRequest, opts ...grpc.CallOption) (*JobErrorsResponse, error)
	GetJobRunDetails(ctx context.Context, in *JobRunDetailsRequest, opts ...grpc.CallOption) (*JobRunDetailsResponse, error)
	GetActiveQueues(ctx context.Context, in *GetActiveQueuesRequest, opts ...grpc.CallOption) (*GetActiveQueuesResponse, error)
}

type jobsClient struct {
	cc *grpc.ClientConn
}

func NewJobsClient(cc *grpc.ClientConn) JobsClient {
	return &jobsClient{cc}
}

func (c *jobsClient) GetJobStatus(ctx context.Context, in *JobStatusRequest, opts ...grpc.CallOption) (*JobStatusResponse, error) {
	out := new(JobStatusResponse)
	err := c.cc.Invoke(ctx, "/api.Jobs/GetJobStatus", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsClient) GetJobStatusUsingExternalJobUri(ctx context.Context, in *JobStatusUsingExternalJobUriRequest, opts ...grpc.CallOption) (*JobStatusResponse, error) {
	out := new(JobStatusResponse)
	err := c.cc.Invoke(ctx, "/api.Jobs/GetJobStatusUsingExternalJobUri", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsClient) GetJobDetails(ctx context.Context, in *JobDetailsRequest, opts ...grpc.CallOption) (*JobDetailsResponse, error) {
	out := new(JobDetailsResponse)
	err := c.cc.Invoke(ctx, "/api.Jobs/GetJobDetails", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsClient) GetJobErrors(ctx context.Context, in *JobErrorsRequest, opts ...grpc.CallOption) (*JobErrorsResponse, error) {
	out := new(JobErrorsResponse)
	err := c.cc.Invoke(ctx, "/api.Jobs/GetJobErrors", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsClient) GetJobRunDetails(ctx context.Context, in *JobRunDetailsRequest, opts ...grpc.CallOption) (*JobRunDetailsResponse, error) {
	out := new(JobRunDetailsResponse)
	err := c.cc.Invoke(ctx, "/api.Jobs/GetJobRunDetails", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *jobsClient) GetActiveQueues(ctx context.Context, in *GetActiveQueuesRequest, opts ...grpc.CallOption) (*GetActiveQueuesResponse, error) {
	out := new(GetActiveQueuesResponse)
	err := c.cc.Invoke(ctx, "/api.Jobs/GetActiveQueues", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// JobsServer is the server API for Jobs service.
type JobsServer interface {
	GetJobStatus(context.Context, *JobStatusRequest) (*JobStatusResponse, error)
	GetJobStatusUsingExternalJobUri(context.Context, *JobStatusUsingExternalJobUriRequest) (*JobStatusResponse, error)
	GetJobDetails(context.Context, *JobDetailsRequest) (*JobDetailsResponse, error)
	GetJobErrors(context.Context, *JobErrorsRequest) (*JobErrorsResponse, error)
	GetJobRunDetails(context.Context, *JobRunDetailsRequest) (*JobRunDetailsResponse, error)
	GetActiveQueues(context.Context, *GetActiveQueuesRequest) (*GetActiveQueuesResponse, error)
}

// UnimplementedJobsServer can be embedded to have forward compatible implementations.
type UnimplementedJobsServer struct {
}

func (*UnimplementedJobsServer) GetJobStatus(ctx context.Context, req *JobStatusRequest) (*JobStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJobStatus not implemented")
}
func (*UnimplementedJobsServer) GetJobStatusUsingExternalJobUri(ctx context.Context, req *JobStatusUsingExternalJobUriRequest) (*JobStatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJobStatusUsingExternalJobUri not implemented")
}
func (*UnimplementedJobsServer) GetJobDetails(ctx context.Context, req *JobDetailsRequest) (*JobDetailsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJobDetails not implemented")
}
func (*UnimplementedJobsServer) GetJobErrors(ctx context.Context, req *JobErrorsRequest) (*JobErrorsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJobErrors not implemented")
}
func (*UnimplementedJobsServer) GetJobRunDetails(ctx context.Context, req *JobRunDetailsRequest) (*JobRunDetailsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetJobRunDetails not implemented")
}
func (*UnimplementedJobsServer) GetActiveQueues(ctx context.Context, req *GetActiveQueuesRequest) (*GetActiveQueuesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetActiveQueues not implemented")
}

func RegisterJobsServer(s *grpc.Server, srv JobsServer) {
	s.RegisterService(&_Jobs_serviceDesc, srv)
}

func _Jobs_GetJobStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JobStatusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServer).GetJobStatus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Jobs/GetJobStatus",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServer).GetJobStatus(ctx, req.(*JobStatusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Jobs_GetJobStatusUsingExternalJobUri_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JobStatusUsingExternalJobUriRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServer).GetJobStatusUsingExternalJobUri(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Jobs/GetJobStatusUsingExternalJobUri",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServer).GetJobStatusUsingExternalJobUri(ctx, req.(*JobStatusUsingExternalJobUriRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Jobs_GetJobDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JobDetailsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServer).GetJobDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Jobs/GetJobDetails",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServer).GetJobDetails(ctx, req.(*JobDetailsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Jobs_GetJobErrors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JobErrorsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServer).GetJobErrors(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Jobs/GetJobErrors",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServer).GetJobErrors(ctx, req.(*JobErrorsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Jobs_GetJobRunDetails_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(JobRunDetailsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServer).GetJobRunDetails(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Jobs/GetJobRunDetails",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServer).GetJobRunDetails(ctx, req.(*JobRunDetailsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Jobs_GetActiveQueues_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetActiveQueuesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(JobsServer).GetActiveQueues(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.Jobs/GetActiveQueues",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(JobsServer).GetActiveQueues(ctx, req.(*GetActiveQueuesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _Jobs_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.Jobs",
	HandlerType: (*JobsServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetJobStatus",
			Handler:    _Jobs_GetJobStatus_Handler,
		},
		{
			MethodName: "GetJobStatusUsingExternalJobUri",
			Handler:    _Jobs_GetJobStatusUsingExternalJobUri_Handler,
		},
		{
			MethodName: "GetJobDetails",
			Handler:    _Jobs_GetJobDetails_Handler,
		},
		{
			MethodName: "GetJobErrors",
			Handler:    _Jobs_GetJobErrors_Handler,
		},
		{
			MethodName: "GetJobRunDetails",
			Handler:    _Jobs_GetJobRunDetails_Handler,
		},
		{
			MethodName: "GetActiveQueues",
			Handler:    _Jobs_GetActiveQueues_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "pkg/api/job.proto",
}

func (m *JobRunDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobRunDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobRunDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.FinishedTs != nil {
		{
			size, err := m.FinishedTs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJob(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.StartedTs != nil {
		{
			size, err := m.StartedTs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJob(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if m.PendingTs != nil {
		{
			size, err := m.PendingTs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJob(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if m.LeasedTs != nil {
		{
			size, err := m.LeasedTs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJob(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Node) > 0 {
		i -= len(m.Node)
		copy(dAtA[i:], m.Node)
		i = encodeVarintJob(dAtA, i, uint64(len(m.Node)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Cluster) > 0 {
		i -= len(m.Cluster)
		copy(dAtA[i:], m.Cluster)
		i = encodeVarintJob(dAtA, i, uint64(len(m.Cluster)))
		i--
		dAtA[i] = 0x22
	}
	if m.State != 0 {
		i = encodeVarintJob(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if len(m.JobId) > 0 {
		i -= len(m.JobId)
		copy(dAtA[i:], m.JobId)
		i = encodeVarintJob(dAtA, i, uint64(len(m.JobId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.RunId) > 0 {
		i -= len(m.RunId)
		copy(dAtA[i:], m.RunId)
		i = encodeVarintJob(dAtA, i, uint64(len(m.RunId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *JobDetails) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.CancelUser) > 0 {
		i -= len(m.CancelUser)
		copy(dAtA[i:], m.CancelUser)
		i = encodeVarintJob(dAtA, i, uint64(len(m.CancelUser)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.JobRuns) > 0 {
		for iNdEx := len(m.JobRuns) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.JobRuns[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintJob(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if m.JobSpec != nil {
		{
			size, err := m.JobSpec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJob(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x5a
	}
	if len(m.LatestRunId) > 0 {
		i -= len(m.LatestRunId)
		copy(dAtA[i:], m.LatestRunId)
		i = encodeVarintJob(dAtA, i, uint64(len(m.LatestRunId)))
		i--
		dAtA[i] = 0x52
	}
	if m.LastTransitionTs != nil {
		{
			size, err := m.LastTransitionTs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJob(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	if len(m.CancelReason) > 0 {
		i -= len(m.CancelReason)
		copy(dAtA[i:], m.CancelReason)
		i = encodeVarintJob(dAtA, i, uint64(len(m.CancelReason)))
		i--
		dAtA[i] = 0x42
	}
	if m.CancelTs != nil {
		{
			size, err := m.CancelTs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJob(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	if m.SubmittedTs != nil {
		{
			size, err := m.SubmittedTs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintJob(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.State != 0 {
		i = encodeVarintJob(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintJob(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Jobset) > 0 {
		i -= len(m.Jobset)
		copy(dAtA[i:], m.Jobset)
		i = encodeVarintJob(dAtA, i, uint64(len(m.Jobset)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Queue) > 0 {
		i -= len(m.Queue)
		copy(dAtA[i:], m.Queue)
		i = encodeVarintJob(dAtA, i, uint64(len(m.Queue)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.JobId) > 0 {
		i -= len(m.JobId)
		copy(dAtA[i:], m.JobId)
		i = encodeVarintJob(dAtA, i, uint64(len(m.JobId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *JobDetailsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobDetailsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobDetailsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ExpandJobRun {
		i--
		if m.ExpandJobRun {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if m.ExpandJobSpec {
		i--
		if m.ExpandJobSpec {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if len(m.JobIds) > 0 {
		for iNdEx := len(m.JobIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.JobIds[iNdEx])
			copy(dAtA[i:], m.JobIds[iNdEx])
			i = encodeVarintJob(dAtA, i, uint64(len(m.JobIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *JobDetailsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobDetailsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobDetailsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JobDetails) > 0 {
		for k := range m.JobDetails {
			v := m.JobDetails[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintJob(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintJob(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintJob(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *JobRunDetailsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobRunDetailsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobRunDetailsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JobRunDetails) > 0 {
		for k := range m.JobRunDetails {
			v := m.JobRunDetails[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintJob(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintJob(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintJob(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *JobRunDetailsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobRunDetailsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobRunDetailsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RunIds) > 0 {
		for iNdEx := len(m.RunIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.RunIds[iNdEx])
			copy(dAtA[i:], m.RunIds[iNdEx])
			i = encodeVarintJob(dAtA, i, uint64(len(m.RunIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *JobErrorsRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobErrorsRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobErrorsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JobIds) > 0 {
		for iNdEx := len(m.JobIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.JobIds[iNdEx])
			copy(dAtA[i:], m.JobIds[iNdEx])
			i = encodeVarintJob(dAtA, i, uint64(len(m.JobIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *JobErrorsResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobErrorsResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobErrorsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JobErrors) > 0 {
		for k := range m.JobErrors {
			v := m.JobErrors[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintJob(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintJob(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintJob(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *JobStatusRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobStatusRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JobIds) > 0 {
		for iNdEx := len(m.JobIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.JobIds[iNdEx])
			copy(dAtA[i:], m.JobIds[iNdEx])
			i = encodeVarintJob(dAtA, i, uint64(len(m.JobIds[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ActiveQueues) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ActiveQueues) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ActiveQueues) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Queues) > 0 {
		for iNdEx := len(m.Queues) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Queues[iNdEx])
			copy(dAtA[i:], m.Queues[iNdEx])
			i = encodeVarintJob(dAtA, i, uint64(len(m.Queues[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GetActiveQueuesRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetActiveQueuesRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetActiveQueuesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	return len(dAtA) - i, nil
}

func (m *GetActiveQueuesResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GetActiveQueuesResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetActiveQueuesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ActiveQueuesByPool) > 0 {
		for k := range m.ActiveQueuesByPool {
			v := m.ActiveQueuesByPool[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintJob(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintJob(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintJob(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *JobStatusUsingExternalJobUriRequest) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobStatusUsingExternalJobUriRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobStatusUsingExternalJobUriRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ExternalJobUri) > 0 {
		i -= len(m.ExternalJobUri)
		copy(dAtA[i:], m.ExternalJobUri)
		i = encodeVarintJob(dAtA, i, uint64(len(m.ExternalJobUri)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Jobset) > 0 {
		i -= len(m.Jobset)
		copy(dAtA[i:], m.Jobset)
		i = encodeVarintJob(dAtA, i, uint64(len(m.Jobset)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Queue) > 0 {
		i -= len(m.Queue)
		copy(dAtA[i:], m.Queue)
		i = encodeVarintJob(dAtA, i, uint64(len(m.Queue)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *JobStatusResponse) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *JobStatusResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.JobStates) > 0 {
		for k := range m.JobStates {
			v := m.JobStates[k]
			baseI := i
			i = encodeVarintJob(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintJob(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintJob(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintJob(dAtA []byte, offset int, v uint64) int {
	offset -= sovJob(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *JobRunDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RunId)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.JobId)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovJob(uint64(m.State))
	}
	l = len(m.Cluster)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.Node)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	if m.LeasedTs != nil {
		l = m.LeasedTs.Size()
		n += 1 + l + sovJob(uint64(l))
	}
	if m.PendingTs != nil {
		l = m.PendingTs.Size()
		n += 1 + l + sovJob(uint64(l))
	}
	if m.StartedTs != nil {
		l = m.StartedTs.Size()
		n += 1 + l + sovJob(uint64(l))
	}
	if m.FinishedTs != nil {
		l = m.FinishedTs.Size()
		n += 1 + l + sovJob(uint64(l))
	}
	return n
}

func (m *JobDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.JobId)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.Queue)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.Jobset)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovJob(uint64(m.State))
	}
	if m.SubmittedTs != nil {
		l = m.SubmittedTs.Size()
		n += 1 + l + sovJob(uint64(l))
	}
	if m.CancelTs != nil {
		l = m.CancelTs.Size()
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.CancelReason)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	if m.LastTransitionTs != nil {
		l = m.LastTransitionTs.Size()
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.LatestRunId)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	if m.JobSpec != nil {
		l = m.JobSpec.Size()
		n += 1 + l + sovJob(uint64(l))
	}
	if len(m.JobRuns) > 0 {
		for _, e := range m.JobRuns {
			l = e.Size()
			n += 1 + l + sovJob(uint64(l))
		}
	}
	l = len(m.CancelUser)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	return n
}

func (m *JobDetailsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.JobIds) > 0 {
		for _, s := range m.JobIds {
			l = len(s)
			n += 1 + l + sovJob(uint64(l))
		}
	}
	if m.ExpandJobSpec {
		n += 2
	}
	if m.ExpandJobRun {
		n += 2
	}
	return n
}

func (m *JobDetailsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.JobDetails) > 0 {
		for k, v := range m.JobDetails {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovJob(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovJob(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovJob(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *JobRunDetailsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.JobRunDetails) > 0 {
		for k, v := range m.JobRunDetails {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovJob(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovJob(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovJob(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *JobRunDetailsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.RunIds) > 0 {
		for _, s := range m.RunIds {
			l = len(s)
			n += 1 + l + sovJob(uint64(l))
		}
	}
	return n
}

func (m *JobErrorsRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.JobIds) > 0 {
		for _, s := range m.JobIds {
			l = len(s)
			n += 1 + l + sovJob(uint64(l))
		}
	}
	return n
}

func (m *JobErrorsResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.JobErrors) > 0 {
		for k, v := range m.JobErrors {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovJob(uint64(len(k))) + 1 + len(v) + sovJob(uint64(len(v)))
			n += mapEntrySize + 1 + sovJob(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *JobStatusRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.JobIds) > 0 {
		for _, s := range m.JobIds {
			l = len(s)
			n += 1 + l + sovJob(uint64(l))
		}
	}
	return n
}

func (m *ActiveQueues) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Queues) > 0 {
		for _, s := range m.Queues {
			l = len(s)
			n += 1 + l + sovJob(uint64(l))
		}
	}
	return n
}

func (m *GetActiveQueuesRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *GetActiveQueuesResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ActiveQueuesByPool) > 0 {
		for k, v := range m.ActiveQueuesByPool {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovJob(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovJob(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovJob(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *JobStatusUsingExternalJobUriRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Queue)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.Jobset)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	l = len(m.ExternalJobUri)
	if l > 0 {
		n += 1 + l + sovJob(uint64(l))
	}
	return n
}

func (m *JobStatusResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.JobStates) > 0 {
		for k, v := range m.JobStates {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovJob(uint64(len(k))) + 1 + sovJob(uint64(v))
			n += mapEntrySize + 1 + sovJob(uint64(mapEntrySize))
		}
	}
	return n
}

func sovJob(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozJob(x uint64) (n int) {
	return sovJob(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *JobRunDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobRunDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobRunDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RunId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RunId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= JobRunState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cluster = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Node = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeasedTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LeasedTs == nil {
				m.LeasedTs = &types.Timestamp{}
			}
			if err := m.LeasedTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PendingTs == nil {
				m.PendingTs = &types.Timestamp{}
			}
			if err := m.PendingTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartedTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.StartedTs == nil {
				m.StartedTs = &types.Timestamp{}
			}
			if err := m.StartedTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinishedTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FinishedTs == nil {
				m.FinishedTs = &types.Timestamp{}
			}
			if err := m.FinishedTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Queue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Queue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Jobset", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Jobset = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= JobState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubmittedTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SubmittedTs == nil {
				m.SubmittedTs = &types.Timestamp{}
			}
			if err := m.SubmittedTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CancelTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CancelTs == nil {
				m.CancelTs = &types.Timestamp{}
			}
			if err := m.CancelTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CancelReason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CancelReason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTransitionTs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LastTransitionTs == nil {
				m.LastTransitionTs = &types.Timestamp{}
			}
			if err := m.LastTransitionTs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LatestRunId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LatestRunId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobSpec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.JobSpec == nil {
				m.JobSpec = &Job{}
			}
			if err := m.JobSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobRuns", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobRuns = append(m.JobRuns, &JobRunDetails{})
			if err := m.JobRuns[len(m.JobRuns)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CancelUser", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CancelUser = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobDetailsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobDetailsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobIds = append(m.JobIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpandJobSpec", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ExpandJobSpec = bool(v != 0)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpandJobRun", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ExpandJobRun = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobDetailsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobDetailsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.JobDetails == nil {
				m.JobDetails = make(map[string]*JobDetails)
			}
			var mapkey string
			var mapvalue *JobDetails
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowJob
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthJob
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthJob
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthJob
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthJob
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &JobDetails{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipJob(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthJob
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.JobDetails[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobRunDetailsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobRunDetailsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobRunDetailsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobRunDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.JobRunDetails == nil {
				m.JobRunDetails = make(map[string]*JobRunDetails)
			}
			var mapkey string
			var mapvalue *JobRunDetails
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowJob
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthJob
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthJob
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthJob
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthJob
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &JobRunDetails{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipJob(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthJob
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.JobRunDetails[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobRunDetailsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobRunDetailsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobRunDetailsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RunIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RunIds = append(m.RunIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobErrorsRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobErrorsRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobErrorsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobIds = append(m.JobIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobErrorsResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobErrorsResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobErrorsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobErrors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.JobErrors == nil {
				m.JobErrors = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowJob
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthJob
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthJob
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthJob
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthJob
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipJob(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthJob
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.JobErrors[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobStatusRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobStatusRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobIds = append(m.JobIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ActiveQueues) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ActiveQueues: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ActiveQueues: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Queues", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Queues = append(m.Queues, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetActiveQueuesRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetActiveQueuesRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetActiveQueuesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetActiveQueuesResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetActiveQueuesResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetActiveQueuesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ActiveQueuesByPool", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ActiveQueuesByPool == nil {
				m.ActiveQueuesByPool = make(map[string]*ActiveQueues)
			}
			var mapkey string
			var mapvalue *ActiveQueues
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowJob
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthJob
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthJob
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthJob
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthJob
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ActiveQueues{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipJob(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthJob
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ActiveQueuesByPool[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobStatusUsingExternalJobUriRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobStatusUsingExternalJobUriRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobStatusUsingExternalJobUriRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Queue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Queue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Jobset", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Jobset = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExternalJobUri", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExternalJobUri = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobStatusResponse) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowJob
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: JobStatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobStates", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowJob
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthJob
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthJob
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.JobStates == nil {
				m.JobStates = make(map[string]JobState)
			}
			var mapkey string
			var mapvalue JobState
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowJob
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthJob
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthJob
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowJob
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= JobState(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipJob(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthJob
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.JobStates[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipJob(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthJob
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipJob(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowJob
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowJob
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowJob
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthJob
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupJob
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthJob
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthJob        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowJob          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupJob = fmt.Errorf("proto: unexpected end of group")
)
