queue.pb.go

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

package api

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strings "strings"
	time "time"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	types "github.com/gogo/protobuf/types"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	v1 "k8s.io/api/core/v1"
	v11 "k8s.io/api/networking/v1"
	resource "k8s.io/apimachinery/pkg/api/resource"
)

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

// 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 Job struct {
	Id                                 string            `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	ClientId                           string            `protobuf:"bytes,13,opt,name=client_id,json=clientId,proto3" json:"clientId,omitempty"`
	JobSetId                           string            `protobuf:"bytes,2,opt,name=job_set_id,json=jobSetId,proto3" json:"jobSetId,omitempty"`
	Queue                              string            `protobuf:"bytes,3,opt,name=queue,proto3" json:"queue,omitempty"`
	Namespace                          string            `protobuf:"bytes,7,opt,name=namespace,proto3" json:"namespace,omitempty"`
	Labels                             map[string]string `protobuf:"bytes,9,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Annotations                        map[string]string `protobuf:"bytes,10,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	RequiredNodeLabels                 map[string]string `protobuf:"bytes,11,rep,name=required_node_labels,json=requiredNodeLabels,proto3" json:"requiredNodeLabels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Deprecated: Do not use.
	Owner                              string            `protobuf:"bytes,8,opt,name=owner,proto3" json:"owner,omitempty"`
	QueueOwnershipUserGroups           []string          `protobuf:"bytes,15,rep,name=queue_ownership_user_groups,json=queueOwnershipUserGroups,proto3" json:"queueOwnershipUserGroups,omitempty"`
	CompressedQueueOwnershipUserGroups []byte            `protobuf:"bytes,19,opt,name=compressed_queue_ownership_user_groups,json=compressedQueueOwnershipUserGroups,proto3" json:"compressedQueueOwnershipUserGroups,omitempty"`
	Priority                           float64           `protobuf:"fixed64,4,opt,name=priority,proto3" json:"priority,omitempty"`
	PodSpec                            *v1.PodSpec       `protobuf:"bytes,5,opt,name=pod_spec,json=podSpec,proto3" json:"podSpec,omitempty"` // Deprecated: Do not use.
	PodSpecs                           []*v1.PodSpec     `protobuf:"bytes,12,rep,name=pod_specs,json=podSpecs,proto3" json:"podSpecs,omitempty"`
	Created                            time.Time         `protobuf:"bytes,6,opt,name=created,proto3,stdtime" json:"created"`
	// Services can be provided either as Armada-specific config objects or as proper k8s objects.
	// These options are exclusive, i.e., if either ingress or services is provided,
	// then neither of k8s_ingress or k8s_service can be provided, and vice versa.
	Ingress    []*IngressConfig `protobuf:"bytes,14,rep,name=ingress,proto3" json:"ingress,omitempty"`
	Services   []*ServiceConfig `protobuf:"bytes,16,rep,name=services,proto3" json:"services,omitempty"`
	K8SIngress []*v11.Ingress   `protobuf:"bytes,17,rep,name=k8s_ingress,json=k8sIngress,proto3" json:"k8sIngress,omitempty"`
	K8SService []*v1.Service    `protobuf:"bytes,18,rep,name=k8s_service,json=k8sService,proto3" json:"k8sService,omitempty"`
	// Indicates which scheduler should manage this job.
	// If empty, the default scheduler is used.
	Scheduler string `protobuf:"bytes,20,opt,name=scheduler,proto3" json:"scheduler,omitempty"`
}

func (m *Job) Reset()      { *m = Job{} }
func (*Job) ProtoMessage() {}
func (*Job) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{0}
}
func (m *Job) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Job) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Job.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 *Job) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Job.Merge(m, src)
}
func (m *Job) XXX_Size() int {
	return m.Size()
}
func (m *Job) XXX_DiscardUnknown() {
	xxx_messageInfo_Job.DiscardUnknown(m)
}

var xxx_messageInfo_Job proto.InternalMessageInfo

func (m *Job) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *Job) GetClientId() string {
	if m != nil {
		return m.ClientId
	}
	return ""
}

func (m *Job) GetJobSetId() string {
	if m != nil {
		return m.JobSetId
	}
	return ""
}

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

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

func (m *Job) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *Job) GetAnnotations() map[string]string {
	if m != nil {
		return m.Annotations
	}
	return nil
}

// Deprecated: Do not use.
func (m *Job) GetRequiredNodeLabels() map[string]string {
	if m != nil {
		return m.RequiredNodeLabels
	}
	return nil
}

func (m *Job) GetOwner() string {
	if m != nil {
		return m.Owner
	}
	return ""
}

func (m *Job) GetQueueOwnershipUserGroups() []string {
	if m != nil {
		return m.QueueOwnershipUserGroups
	}
	return nil
}

func (m *Job) GetCompressedQueueOwnershipUserGroups() []byte {
	if m != nil {
		return m.CompressedQueueOwnershipUserGroups
	}
	return nil
}

func (m *Job) GetPriority() float64 {
	if m != nil {
		return m.Priority
	}
	return 0
}

// Deprecated: Do not use.
func (m *Job) GetPodSpec() *v1.PodSpec {
	if m != nil {
		return m.PodSpec
	}
	return nil
}

func (m *Job) GetPodSpecs() []*v1.PodSpec {
	if m != nil {
		return m.PodSpecs
	}
	return nil
}

func (m *Job) GetCreated() time.Time {
	if m != nil {
		return m.Created
	}
	return time.Time{}
}

func (m *Job) GetIngress() []*IngressConfig {
	if m != nil {
		return m.Ingress
	}
	return nil
}

func (m *Job) GetServices() []*ServiceConfig {
	if m != nil {
		return m.Services
	}
	return nil
}

func (m *Job) GetK8SIngress() []*v11.Ingress {
	if m != nil {
		return m.K8SIngress
	}
	return nil
}

func (m *Job) GetK8SService() []*v1.Service {
	if m != nil {
		return m.K8SService
	}
	return nil
}

func (m *Job) GetScheduler() string {
	if m != nil {
		return m.Scheduler
	}
	return ""
}

// For the bidirectional streaming job lease request service.
// For the first message, populate all fields except SubmittedJobs, which should be empty.
// For subsequent messages, these fields may be left empty, in which case the last non-zero value received is used.
// By streaming back job ids, the server knows which jobs were received in case of an outage.
type StreamingLeaseRequest struct {
	// Each cluster has a unique name associated with it.
	ClusterId string `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"clusterId,omitempty"`
	// Nodes are split into pools. This field indicates for which pool jobs are leased.
	Pool string `protobuf:"bytes,2,opt,name=pool,proto3" json:"pool,omitempty"`
	// Total resources available for scheduling across all nodes.
	Resources map[string]resource.Quantity `protobuf:"bytes,3,rep,name=resources,proto3" json:"resources" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// For each queue, the total resources allocated to jobs from that queue.
	ClusterLeasedReport ClusterLeasedReport `protobuf:"bytes,4,opt,name=cluster_leased_report,json=clusterLeasedReport,proto3" json:"clusterLeasedReport"`
	// Jobs submitted to this executor must require at least this amount of resources.
	MinimumJobSize map[string]resource.Quantity `protobuf:"bytes,5,rep,name=minimum_job_size,json=minimumJobSize,proto3" json:"minimumJobSize" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// For each node in the cluster:
	// - the total resources on that node,
	// - the amount of resources already assigned to jobs, and
	// - any taints and labels on the node.
	Nodes []NodeInfo `protobuf:"bytes,6,rep,name=nodes,proto3" json:"nodes"`
	// Ids of received jobs. Used to ack received jobs.
	ReceivedJobIds []string `protobuf:"bytes,7,rep,name=ReceivedJobIds,proto3" json:"ReceivedJobIds,omitempty"`
}

func (m *StreamingLeaseRequest) Reset()      { *m = StreamingLeaseRequest{} }
func (*StreamingLeaseRequest) ProtoMessage() {}
func (*StreamingLeaseRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{1}
}
func (m *StreamingLeaseRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamingLeaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamingLeaseRequest.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 *StreamingLeaseRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamingLeaseRequest.Merge(m, src)
}
func (m *StreamingLeaseRequest) XXX_Size() int {
	return m.Size()
}
func (m *StreamingLeaseRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamingLeaseRequest.DiscardUnknown(m)
}

var xxx_messageInfo_StreamingLeaseRequest proto.InternalMessageInfo

func (m *StreamingLeaseRequest) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *StreamingLeaseRequest) GetPool() string {
	if m != nil {
		return m.Pool
	}
	return ""
}

func (m *StreamingLeaseRequest) GetResources() map[string]resource.Quantity {
	if m != nil {
		return m.Resources
	}
	return nil
}

func (m *StreamingLeaseRequest) GetClusterLeasedReport() ClusterLeasedReport {
	if m != nil {
		return m.ClusterLeasedReport
	}
	return ClusterLeasedReport{}
}

func (m *StreamingLeaseRequest) GetMinimumJobSize() map[string]resource.Quantity {
	if m != nil {
		return m.MinimumJobSize
	}
	return nil
}

func (m *StreamingLeaseRequest) GetNodes() []NodeInfo {
	if m != nil {
		return m.Nodes
	}
	return nil
}

func (m *StreamingLeaseRequest) GetReceivedJobIds() []string {
	if m != nil {
		return m.ReceivedJobIds
	}
	return nil
}

// Used by the scheduler when allocating jobs to executors.
type NodeInfo struct {
	Name   string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Taints []v1.Taint        `protobuf:"bytes,2,rep,name=taints,proto3" json:"taints"`
	Labels map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// To be deprecated in favour of total_resources + allocated_resources.
	AllocatableResources map[string]resource.Quantity `protobuf:"bytes,4,rep,name=allocatable_resources,json=allocatableResources,proto3" json:"allocatableResources" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// To be deprecated in favour of total_resources + allocated_resources.
	AvailableResources map[string]resource.Quantity `protobuf:"bytes,5,rep,name=available_resources,json=availableResources,proto3" json:"availableResources" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Total node resources.
	// Resources available for allocation is given by the difference between this and allocated_resources.
	TotalResources map[string]resource.Quantity `protobuf:"bytes,6,rep,name=total_resources,json=totalResources,proto3" json:"totalResources" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Each pod is created with a priority class. Each priority class has an integer priority associated with it.
	// This is a map from priority to the total amount of resources allocated to pods with that priority.
	// It is used by the scheduler to decide whether more jobs should be sent to an executor.
	// In particular, jobs may be sent to an executor even if all resources are allocated
	// if the sent jobs are of higher priority.
	AllocatedResources map[int32]ComputeResource `protobuf:"bytes,7,rep,name=allocated_resources,json=allocatedResources,proto3" json:"allocatedResources" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// All run ids of jobs on the node, mapped to their current state
	// this should be of type armadaevents.uuid, but this creates a circular loop
	// once the old scheduler has gone, we can correct this
	RunIdsByState map[string]JobState `protobuf:"bytes,8,rep,name=run_ids_by_state,json=runIdsByState,proto3" json:"runIdsByState" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3,enum=api.JobState"`
	// The amount of resource allocated to non-armada pods by priority
	NonArmadaAllocatedResources map[int32]ComputeResource `protobuf:"bytes,9,rep,name=non_armada_allocated_resources,json=nonArmadaAllocatedResources,proto3" json:"nonArmadaAllocatedResources" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Unschedulable               bool                      `protobuf:"varint,10,opt,name=unschedulable,proto3" json:"unschedulable,omitempty"`
}

func (m *NodeInfo) Reset()      { *m = NodeInfo{} }
func (*NodeInfo) ProtoMessage() {}
func (*NodeInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{2}
}
func (m *NodeInfo) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NodeInfo.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 *NodeInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeInfo.Merge(m, src)
}
func (m *NodeInfo) XXX_Size() int {
	return m.Size()
}
func (m *NodeInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeInfo.DiscardUnknown(m)
}

var xxx_messageInfo_NodeInfo proto.InternalMessageInfo

func (m *NodeInfo) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *NodeInfo) GetTaints() []v1.Taint {
	if m != nil {
		return m.Taints
	}
	return nil
}

func (m *NodeInfo) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *NodeInfo) GetAllocatableResources() map[string]resource.Quantity {
	if m != nil {
		return m.AllocatableResources
	}
	return nil
}

func (m *NodeInfo) GetAvailableResources() map[string]resource.Quantity {
	if m != nil {
		return m.AvailableResources
	}
	return nil
}

func (m *NodeInfo) GetTotalResources() map[string]resource.Quantity {
	if m != nil {
		return m.TotalResources
	}
	return nil
}

func (m *NodeInfo) GetAllocatedResources() map[int32]ComputeResource {
	if m != nil {
		return m.AllocatedResources
	}
	return nil
}

func (m *NodeInfo) GetRunIdsByState() map[string]JobState {
	if m != nil {
		return m.RunIdsByState
	}
	return nil
}

func (m *NodeInfo) GetNonArmadaAllocatedResources() map[int32]ComputeResource {
	if m != nil {
		return m.NonArmadaAllocatedResources
	}
	return nil
}

func (m *NodeInfo) GetUnschedulable() bool {
	if m != nil {
		return m.Unschedulable
	}
	return false
}

// The Armada scheduler must account for taints, labels, and available resources.
// These together make up the NodeType of a particular node.
// Nodes with equal NodeType are considered as equivalent for scheduling and accounting.
type NodeType struct {
	Taints               []v1.Taint                   `protobuf:"bytes,1,rep,name=taints,proto3" json:"taints"`
	Labels               map[string]string            `protobuf:"bytes,2,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	AllocatableResources map[string]resource.Quantity `protobuf:"bytes,3,rep,name=allocatable_resources,json=allocatableResources,proto3" json:"allocatableResources" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *NodeType) Reset()      { *m = NodeType{} }
func (*NodeType) ProtoMessage() {}
func (*NodeType) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{3}
}
func (m *NodeType) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeType) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NodeType.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 *NodeType) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeType.Merge(m, src)
}
func (m *NodeType) XXX_Size() int {
	return m.Size()
}
func (m *NodeType) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeType.DiscardUnknown(m)
}

var xxx_messageInfo_NodeType proto.InternalMessageInfo

func (m *NodeType) GetTaints() []v1.Taint {
	if m != nil {
		return m.Taints
	}
	return nil
}

func (m *NodeType) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *NodeType) GetAllocatableResources() map[string]resource.Quantity {
	if m != nil {
		return m.AllocatableResources
	}
	return nil
}

// Used to store last info in Redis
type ClusterSchedulingInfoReport struct {
	ClusterId      string                       `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"clusterId,omitempty"`
	Pool           string                       `protobuf:"bytes,7,opt,name=pool,proto3" json:"pool,omitempty"`
	ReportTime     time.Time                    `protobuf:"bytes,2,opt,name=report_time,json=reportTime,proto3,stdtime" json:"reportTime"`
	NodeTypes      []*NodeType                  `protobuf:"bytes,5,rep,name=node_types,json=nodeTypes,proto3" json:"nodeTypes,omitempty"`
	MinimumJobSize map[string]resource.Quantity `protobuf:"bytes,6,rep,name=minimum_job_size,json=minimumJobSize,proto3" json:"minimumJobSize" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *ClusterSchedulingInfoReport) Reset()      { *m = ClusterSchedulingInfoReport{} }
func (*ClusterSchedulingInfoReport) ProtoMessage() {}
func (*ClusterSchedulingInfoReport) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{4}
}
func (m *ClusterSchedulingInfoReport) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterSchedulingInfoReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ClusterSchedulingInfoReport.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 *ClusterSchedulingInfoReport) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterSchedulingInfoReport.Merge(m, src)
}
func (m *ClusterSchedulingInfoReport) XXX_Size() int {
	return m.Size()
}
func (m *ClusterSchedulingInfoReport) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterSchedulingInfoReport.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterSchedulingInfoReport proto.InternalMessageInfo

func (m *ClusterSchedulingInfoReport) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *ClusterSchedulingInfoReport) GetPool() string {
	if m != nil {
		return m.Pool
	}
	return ""
}

func (m *ClusterSchedulingInfoReport) GetReportTime() time.Time {
	if m != nil {
		return m.ReportTime
	}
	return time.Time{}
}

func (m *ClusterSchedulingInfoReport) GetNodeTypes() []*NodeType {
	if m != nil {
		return m.NodeTypes
	}
	return nil
}

func (m *ClusterSchedulingInfoReport) GetMinimumJobSize() map[string]resource.Quantity {
	if m != nil {
		return m.MinimumJobSize
	}
	return nil
}

type QueueLeasedReport struct {
	// Queue name.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Total resources allocated to jobs from this queue.
	ResourcesLeased map[string]resource.Quantity `protobuf:"bytes,2,rep,name=resources_leased,json=resourcesLeased,proto3" json:"resourcesLeased" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Total resources allocated to jobs from this queue,
	// grouped by pod priority.
	ResourcesLeasedByPriority map[int32]ComputeResource `protobuf:"bytes,3,rep,name=resources_leased_by_priority,json=resourcesLeasedByPriority,proto3" json:"resourcesLeasedByPriority" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *QueueLeasedReport) Reset()      { *m = QueueLeasedReport{} }
func (*QueueLeasedReport) ProtoMessage() {}
func (*QueueLeasedReport) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{5}
}
func (m *QueueLeasedReport) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *QueueLeasedReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_QueueLeasedReport.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 *QueueLeasedReport) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueueLeasedReport.Merge(m, src)
}
func (m *QueueLeasedReport) XXX_Size() int {
	return m.Size()
}
func (m *QueueLeasedReport) XXX_DiscardUnknown() {
	xxx_messageInfo_QueueLeasedReport.DiscardUnknown(m)
}

var xxx_messageInfo_QueueLeasedReport proto.InternalMessageInfo

func (m *QueueLeasedReport) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *QueueLeasedReport) GetResourcesLeased() map[string]resource.Quantity {
	if m != nil {
		return m.ResourcesLeased
	}
	return nil
}

func (m *QueueLeasedReport) GetResourcesLeasedByPriority() map[int32]ComputeResource {
	if m != nil {
		return m.ResourcesLeasedByPriority
	}
	return nil
}

type ClusterLeasedReport struct {
	ClusterId  string    `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"clusterId,omitempty"`
	ReportTime time.Time `protobuf:"bytes,2,opt,name=report_time,json=reportTime,proto3,stdtime" json:"reportTime"`
	// For each queue, the total resources allocated to jobs from that queue.
	Queues []*QueueLeasedReport `protobuf:"bytes,3,rep,name=queues,proto3" json:"queues,omitempty"`
}

func (m *ClusterLeasedReport) Reset()      { *m = ClusterLeasedReport{} }
func (*ClusterLeasedReport) ProtoMessage() {}
func (*ClusterLeasedReport) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{6}
}
func (m *ClusterLeasedReport) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ClusterLeasedReport) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ClusterLeasedReport.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 *ClusterLeasedReport) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClusterLeasedReport.Merge(m, src)
}
func (m *ClusterLeasedReport) XXX_Size() int {
	return m.Size()
}
func (m *ClusterLeasedReport) XXX_DiscardUnknown() {
	xxx_messageInfo_ClusterLeasedReport.DiscardUnknown(m)
}

var xxx_messageInfo_ClusterLeasedReport proto.InternalMessageInfo

func (m *ClusterLeasedReport) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *ClusterLeasedReport) GetReportTime() time.Time {
	if m != nil {
		return m.ReportTime
	}
	return time.Time{}
}

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

type ComputeResource struct {
	Resources map[string]resource.Quantity `protobuf:"bytes,1,rep,name=resources,proto3" json:"resources" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *ComputeResource) Reset()      { *m = ComputeResource{} }
func (*ComputeResource) ProtoMessage() {}
func (*ComputeResource) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{7}
}
func (m *ComputeResource) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ComputeResource) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ComputeResource.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 *ComputeResource) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ComputeResource.Merge(m, src)
}
func (m *ComputeResource) XXX_Size() int {
	return m.Size()
}
func (m *ComputeResource) XXX_DiscardUnknown() {
	xxx_messageInfo_ComputeResource.DiscardUnknown(m)
}

var xxx_messageInfo_ComputeResource proto.InternalMessageInfo

func (m *ComputeResource) GetResources() map[string]resource.Quantity {
	if m != nil {
		return m.Resources
	}
	return nil
}

type NodeLabeling struct {
	Labels map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *NodeLabeling) Reset()      { *m = NodeLabeling{} }
func (*NodeLabeling) ProtoMessage() {}
func (*NodeLabeling) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{8}
}
func (m *NodeLabeling) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *NodeLabeling) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_NodeLabeling.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 *NodeLabeling) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NodeLabeling.Merge(m, src)
}
func (m *NodeLabeling) XXX_Size() int {
	return m.Size()
}
func (m *NodeLabeling) XXX_DiscardUnknown() {
	xxx_messageInfo_NodeLabeling.DiscardUnknown(m)
}

var xxx_messageInfo_NodeLabeling proto.InternalMessageInfo

func (m *NodeLabeling) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

type JobLease struct {
	Job []*Job `protobuf:"bytes,1,rep,name=job,proto3" json:"job,omitempty"`
}

func (m *JobLease) Reset()      { *m = JobLease{} }
func (*JobLease) ProtoMessage() {}
func (*JobLease) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{9}
}
func (m *JobLease) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *JobLease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_JobLease.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 *JobLease) XXX_Merge(src proto.Message) {
	xxx_messageInfo_JobLease.Merge(m, src)
}
func (m *JobLease) XXX_Size() int {
	return m.Size()
}
func (m *JobLease) XXX_DiscardUnknown() {
	xxx_messageInfo_JobLease.DiscardUnknown(m)
}

var xxx_messageInfo_JobLease proto.InternalMessageInfo

func (m *JobLease) GetJob() []*Job {
	if m != nil {
		return m.Job
	}
	return nil
}

type StreamingJobLease struct {
	Job *Job `protobuf:"bytes,1,opt,name=job,proto3" json:"job,omitempty"`
	// Total number of jobs being sent over this connection.
	NumJobs uint32 `protobuf:"varint,2,opt,name=numJobs,proto3" json:"numJobs,omitempty"`
	// Number of jobs for which the server has received an ack.
	// When numAcked = numJobs, all jobs have been received and acked.
	NumAcked uint32 `protobuf:"varint,3,opt,name=numAcked,proto3" json:"numAcked,omitempty"`
}

func (m *StreamingJobLease) Reset()      { *m = StreamingJobLease{} }
func (*StreamingJobLease) ProtoMessage() {}
func (*StreamingJobLease) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{10}
}
func (m *StreamingJobLease) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StreamingJobLease) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StreamingJobLease.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 *StreamingJobLease) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StreamingJobLease.Merge(m, src)
}
func (m *StreamingJobLease) XXX_Size() int {
	return m.Size()
}
func (m *StreamingJobLease) XXX_DiscardUnknown() {
	xxx_messageInfo_StreamingJobLease.DiscardUnknown(m)
}

var xxx_messageInfo_StreamingJobLease proto.InternalMessageInfo

func (m *StreamingJobLease) GetJob() *Job {
	if m != nil {
		return m.Job
	}
	return nil
}

func (m *StreamingJobLease) GetNumJobs() uint32 {
	if m != nil {
		return m.NumJobs
	}
	return 0
}

func (m *StreamingJobLease) GetNumAcked() uint32 {
	if m != nil {
		return m.NumAcked
	}
	return 0
}

type IdList struct {
	Ids []string `protobuf:"bytes,1,rep,name=ids,proto3" json:"ids,omitempty"`
}

func (m *IdList) Reset()      { *m = IdList{} }
func (*IdList) ProtoMessage() {}
func (*IdList) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{11}
}
func (m *IdList) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *IdList) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_IdList.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 *IdList) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IdList.Merge(m, src)
}
func (m *IdList) XXX_Size() int {
	return m.Size()
}
func (m *IdList) XXX_DiscardUnknown() {
	xxx_messageInfo_IdList.DiscardUnknown(m)
}

var xxx_messageInfo_IdList proto.InternalMessageInfo

func (m *IdList) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type RenewLeaseRequest struct {
	ClusterId string   `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"clusterId,omitempty"`
	Ids       []string `protobuf:"bytes,2,rep,name=ids,proto3" json:"ids,omitempty"`
}

func (m *RenewLeaseRequest) Reset()      { *m = RenewLeaseRequest{} }
func (*RenewLeaseRequest) ProtoMessage() {}
func (*RenewLeaseRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{12}
}
func (m *RenewLeaseRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RenewLeaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RenewLeaseRequest.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 *RenewLeaseRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RenewLeaseRequest.Merge(m, src)
}
func (m *RenewLeaseRequest) XXX_Size() int {
	return m.Size()
}
func (m *RenewLeaseRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_RenewLeaseRequest.DiscardUnknown(m)
}

var xxx_messageInfo_RenewLeaseRequest proto.InternalMessageInfo

func (m *RenewLeaseRequest) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

func (m *RenewLeaseRequest) GetIds() []string {
	if m != nil {
		return m.Ids
	}
	return nil
}

type ReturnLeaseRequest struct {
	ClusterId       string            `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"clusterId,omitempty"`
	JobId           string            `protobuf:"bytes,2,opt,name=job_id,json=jobId,proto3" json:"jobId,omitempty"`
	AvoidNodeLabels *OrderedStringMap `protobuf:"bytes,4,opt,name=avoid_node_labels,json=avoidNodeLabels,proto3" json:"avoidNodeLabels,omitempty"`
	Reason          string            `protobuf:"bytes,5,opt,name=reason,proto3" json:"reason,omitempty"`
	KubernetesId    string            `protobuf:"bytes,6,opt,name=kubernetes_id,json=kubernetesId,proto3" json:"kubernetesId,omitempty"`
	JobRunAttempted bool              `protobuf:"varint,7,opt,name=job_run_attempted,json=jobRunAttempted,proto3" json:"jobRunAttempted,omitempty"`
	// The executor feeds back certain annotations.
	TrackedAnnotations map[string]string `protobuf:"bytes,8,rep,name=tracked_annotations,json=trackedAnnotations,proto3" json:"trackedAnnotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *ReturnLeaseRequest) Reset()      { *m = ReturnLeaseRequest{} }
func (*ReturnLeaseRequest) ProtoMessage() {}
func (*ReturnLeaseRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{13}
}
func (m *ReturnLeaseRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ReturnLeaseRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ReturnLeaseRequest.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 *ReturnLeaseRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ReturnLeaseRequest.Merge(m, src)
}
func (m *ReturnLeaseRequest) XXX_Size() int {
	return m.Size()
}
func (m *ReturnLeaseRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ReturnLeaseRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ReturnLeaseRequest proto.InternalMessageInfo

func (m *ReturnLeaseRequest) GetClusterId() string {
	if m != nil {
		return m.ClusterId
	}
	return ""
}

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

func (m *ReturnLeaseRequest) GetAvoidNodeLabels() *OrderedStringMap {
	if m != nil {
		return m.AvoidNodeLabels
	}
	return nil
}

func (m *ReturnLeaseRequest) GetReason() string {
	if m != nil {
		return m.Reason
	}
	return ""
}

func (m *ReturnLeaseRequest) GetKubernetesId() string {
	if m != nil {
		return m.KubernetesId
	}
	return ""
}

func (m *ReturnLeaseRequest) GetJobRunAttempted() bool {
	if m != nil {
		return m.JobRunAttempted
	}
	return false
}

func (m *ReturnLeaseRequest) GetTrackedAnnotations() map[string]string {
	if m != nil {
		return m.TrackedAnnotations
	}
	return nil
}

type StringKeyValuePair struct {
	Key   string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (m *StringKeyValuePair) Reset()      { *m = StringKeyValuePair{} }
func (*StringKeyValuePair) ProtoMessage() {}
func (*StringKeyValuePair) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{14}
}
func (m *StringKeyValuePair) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *StringKeyValuePair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_StringKeyValuePair.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 *StringKeyValuePair) XXX_Merge(src proto.Message) {
	xxx_messageInfo_StringKeyValuePair.Merge(m, src)
}
func (m *StringKeyValuePair) XXX_Size() int {
	return m.Size()
}
func (m *StringKeyValuePair) XXX_DiscardUnknown() {
	xxx_messageInfo_StringKeyValuePair.DiscardUnknown(m)
}

var xxx_messageInfo_StringKeyValuePair proto.InternalMessageInfo

func (m *StringKeyValuePair) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *StringKeyValuePair) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type OrderedStringMap struct {
	Entries []*StringKeyValuePair `protobuf:"bytes,1,rep,name=entries,proto3" json:"entries,omitempty"`
}

func (m *OrderedStringMap) Reset()      { *m = OrderedStringMap{} }
func (*OrderedStringMap) ProtoMessage() {}
func (*OrderedStringMap) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{15}
}
func (m *OrderedStringMap) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *OrderedStringMap) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_OrderedStringMap.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 *OrderedStringMap) XXX_Merge(src proto.Message) {
	xxx_messageInfo_OrderedStringMap.Merge(m, src)
}
func (m *OrderedStringMap) XXX_Size() int {
	return m.Size()
}
func (m *OrderedStringMap) XXX_DiscardUnknown() {
	xxx_messageInfo_OrderedStringMap.DiscardUnknown(m)
}

var xxx_messageInfo_OrderedStringMap proto.InternalMessageInfo

func (m *OrderedStringMap) GetEntries() []*StringKeyValuePair {
	if m != nil {
		return m.Entries
	}
	return nil
}

func init() {
	proto.RegisterType((*Job)(nil), "api.Job")
	proto.RegisterMapType((map[string]string)(nil), "api.Job.AnnotationsEntry")
	proto.RegisterMapType((map[string]string)(nil), "api.Job.LabelsEntry")
	proto.RegisterMapType((map[string]string)(nil), "api.Job.RequiredNodeLabelsEntry")
	proto.RegisterType((*StreamingLeaseRequest)(nil), "api.StreamingLeaseRequest")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.StreamingLeaseRequest.MinimumJobSizeEntry")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.StreamingLeaseRequest.ResourcesEntry")
	proto.RegisterType((*NodeInfo)(nil), "api.NodeInfo")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.NodeInfo.AllocatableResourcesEntry")
	proto.RegisterMapType((map[int32]ComputeResource)(nil), "api.NodeInfo.AllocatedResourcesEntry")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.NodeInfo.AvailableResourcesEntry")
	proto.RegisterMapType((map[string]string)(nil), "api.NodeInfo.LabelsEntry")
	proto.RegisterMapType((map[int32]ComputeResource)(nil), "api.NodeInfo.NonArmadaAllocatedResourcesEntry")
	proto.RegisterMapType((map[string]JobState)(nil), "api.NodeInfo.RunIdsByStateEntry")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.NodeInfo.TotalResourcesEntry")
	proto.RegisterType((*NodeType)(nil), "api.NodeType")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.NodeType.AllocatableResourcesEntry")
	proto.RegisterMapType((map[string]string)(nil), "api.NodeType.LabelsEntry")
	proto.RegisterType((*ClusterSchedulingInfoReport)(nil), "api.ClusterSchedulingInfoReport")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.ClusterSchedulingInfoReport.MinimumJobSizeEntry")
	proto.RegisterType((*QueueLeasedReport)(nil), "api.QueueLeasedReport")
	proto.RegisterMapType((map[int32]ComputeResource)(nil), "api.QueueLeasedReport.ResourcesLeasedByPriorityEntry")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.QueueLeasedReport.ResourcesLeasedEntry")
	proto.RegisterType((*ClusterLeasedReport)(nil), "api.ClusterLeasedReport")
	proto.RegisterType((*ComputeResource)(nil), "api.ComputeResource")
	proto.RegisterMapType((map[string]resource.Quantity)(nil), "api.ComputeResource.ResourcesEntry")
	proto.RegisterType((*NodeLabeling)(nil), "api.NodeLabeling")
	proto.RegisterMapType((map[string]string)(nil), "api.NodeLabeling.LabelsEntry")
	proto.RegisterType((*JobLease)(nil), "api.JobLease")
	proto.RegisterType((*StreamingJobLease)(nil), "api.StreamingJobLease")
	proto.RegisterType((*IdList)(nil), "api.IdList")
	proto.RegisterType((*RenewLeaseRequest)(nil), "api.RenewLeaseRequest")
	proto.RegisterType((*ReturnLeaseRequest)(nil), "api.ReturnLeaseRequest")
	proto.RegisterMapType((map[string]string)(nil), "api.ReturnLeaseRequest.TrackedAnnotationsEntry")
	proto.RegisterType((*StringKeyValuePair)(nil), "api.StringKeyValuePair")
	proto.RegisterType((*OrderedStringMap)(nil), "api.OrderedStringMap")
}

func init() { proto.RegisterFile("pkg/api/queue.proto", fileDescriptor_d92c0c680df9617a) }

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

// AggregatedQueueClient is the client API for AggregatedQueue service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type AggregatedQueueClient interface {
	StreamingLeaseJobs(ctx context.Context, opts ...grpc.CallOption) (AggregatedQueue_StreamingLeaseJobsClient, error)
	RenewLease(ctx context.Context, in *RenewLeaseRequest, opts ...grpc.CallOption) (*IdList, error)
	ReturnLease(ctx context.Context, in *ReturnLeaseRequest, opts ...grpc.CallOption) (*types.Empty, error)
	ReportDone(ctx context.Context, in *IdList, opts ...grpc.CallOption) (*IdList, error)
}

type aggregatedQueueClient struct {
	cc *grpc.ClientConn
}

func NewAggregatedQueueClient(cc *grpc.ClientConn) AggregatedQueueClient {
	return &aggregatedQueueClient{cc}
}

func (c *aggregatedQueueClient) StreamingLeaseJobs(ctx context.Context, opts ...grpc.CallOption) (AggregatedQueue_StreamingLeaseJobsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_AggregatedQueue_serviceDesc.Streams[0], "/api.AggregatedQueue/StreamingLeaseJobs", opts...)
	if err != nil {
		return nil, err
	}
	x := &aggregatedQueueStreamingLeaseJobsClient{stream}
	return x, nil
}

type AggregatedQueue_StreamingLeaseJobsClient interface {
	Send(*StreamingLeaseRequest) error
	Recv() (*StreamingJobLease, error)
	grpc.ClientStream
}

type aggregatedQueueStreamingLeaseJobsClient struct {
	grpc.ClientStream
}

func (x *aggregatedQueueStreamingLeaseJobsClient) Send(m *StreamingLeaseRequest) error {
	return x.ClientStream.SendMsg(m)
}

func (x *aggregatedQueueStreamingLeaseJobsClient) Recv() (*StreamingJobLease, error) {
	m := new(StreamingJobLease)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *aggregatedQueueClient) RenewLease(ctx context.Context, in *RenewLeaseRequest, opts ...grpc.CallOption) (*IdList, error) {
	out := new(IdList)
	err := c.cc.Invoke(ctx, "/api.AggregatedQueue/RenewLease", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatedQueueClient) ReturnLease(ctx context.Context, in *ReturnLeaseRequest, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/api.AggregatedQueue/ReturnLease", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *aggregatedQueueClient) ReportDone(ctx context.Context, in *IdList, opts ...grpc.CallOption) (*IdList, error) {
	out := new(IdList)
	err := c.cc.Invoke(ctx, "/api.AggregatedQueue/ReportDone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// AggregatedQueueServer is the server API for AggregatedQueue service.
type AggregatedQueueServer interface {
	StreamingLeaseJobs(AggregatedQueue_StreamingLeaseJobsServer) error
	RenewLease(context.Context, *RenewLeaseRequest) (*IdList, error)
	ReturnLease(context.Context, *ReturnLeaseRequest) (*types.Empty, error)
	ReportDone(context.Context, *IdList) (*IdList, error)
}

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

func (*UnimplementedAggregatedQueueServer) StreamingLeaseJobs(srv AggregatedQueue_StreamingLeaseJobsServer) error {
	return status.Errorf(codes.Unimplemented, "method StreamingLeaseJobs not implemented")
}
func (*UnimplementedAggregatedQueueServer) RenewLease(ctx context.Context, req *RenewLeaseRequest) (*IdList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RenewLease not implemented")
}
func (*UnimplementedAggregatedQueueServer) ReturnLease(ctx context.Context, req *ReturnLeaseRequest) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReturnLease not implemented")
}
func (*UnimplementedAggregatedQueueServer) ReportDone(ctx context.Context, req *IdList) (*IdList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ReportDone not implemented")
}

func RegisterAggregatedQueueServer(s *grpc.Server, srv AggregatedQueueServer) {
	s.RegisterService(&_AggregatedQueue_serviceDesc, srv)
}

func _AggregatedQueue_StreamingLeaseJobs_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(AggregatedQueueServer).StreamingLeaseJobs(&aggregatedQueueStreamingLeaseJobsServer{stream})
}

type AggregatedQueue_StreamingLeaseJobsServer interface {
	Send(*StreamingJobLease) error
	Recv() (*StreamingLeaseRequest, error)
	grpc.ServerStream
}

type aggregatedQueueStreamingLeaseJobsServer struct {
	grpc.ServerStream
}

func (x *aggregatedQueueStreamingLeaseJobsServer) Send(m *StreamingJobLease) error {
	return x.ServerStream.SendMsg(m)
}

func (x *aggregatedQueueStreamingLeaseJobsServer) Recv() (*StreamingLeaseRequest, error) {
	m := new(StreamingLeaseRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _AggregatedQueue_RenewLease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RenewLeaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatedQueueServer).RenewLease(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.AggregatedQueue/RenewLease",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatedQueueServer).RenewLease(ctx, req.(*RenewLeaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AggregatedQueue_ReturnLease_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ReturnLeaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatedQueueServer).ReturnLease(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.AggregatedQueue/ReturnLease",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatedQueueServer).ReturnLease(ctx, req.(*ReturnLeaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _AggregatedQueue_ReportDone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(IdList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatedQueueServer).ReportDone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.AggregatedQueue/ReportDone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatedQueueServer).ReportDone(ctx, req.(*IdList))
	}
	return interceptor(ctx, in, info, handler)
}

var _AggregatedQueue_serviceDesc = grpc.ServiceDesc{
	ServiceName: "api.AggregatedQueue",
	HandlerType: (*AggregatedQueueServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RenewLease",
			Handler:    _AggregatedQueue_RenewLease_Handler,
		},
		{
			MethodName: "ReturnLease",
			Handler:    _AggregatedQueue_ReturnLease_Handler,
		},
		{
			MethodName: "ReportDone",
			Handler:    _AggregatedQueue_ReportDone_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "StreamingLeaseJobs",
			Handler:       _AggregatedQueue_StreamingLeaseJobs_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "pkg/api/queue.proto",
}

func (m *Job) 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 *Job) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Job) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Scheduler) > 0 {
		i -= len(m.Scheduler)
		copy(dAtA[i:], m.Scheduler)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Scheduler)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa2
	}
	if len(m.CompressedQueueOwnershipUserGroups) > 0 {
		i -= len(m.CompressedQueueOwnershipUserGroups)
		copy(dAtA[i:], m.CompressedQueueOwnershipUserGroups)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.CompressedQueueOwnershipUserGroups)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if len(m.K8SService) > 0 {
		for iNdEx := len(m.K8SService) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.K8SService[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.K8SIngress) > 0 {
		for iNdEx := len(m.K8SIngress) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.K8SIngress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x8a
		}
	}
	if len(m.Services) > 0 {
		for iNdEx := len(m.Services) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Services[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x82
		}
	}
	if len(m.QueueOwnershipUserGroups) > 0 {
		for iNdEx := len(m.QueueOwnershipUserGroups) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.QueueOwnershipUserGroups[iNdEx])
			copy(dAtA[i:], m.QueueOwnershipUserGroups[iNdEx])
			i = encodeVarintQueue(dAtA, i, uint64(len(m.QueueOwnershipUserGroups[iNdEx])))
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.Ingress) > 0 {
		for iNdEx := len(m.Ingress) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Ingress[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.ClientId) > 0 {
		i -= len(m.ClientId)
		copy(dAtA[i:], m.ClientId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.ClientId)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.PodSpecs) > 0 {
		for iNdEx := len(m.PodSpecs) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.PodSpecs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x62
		}
	}
	if len(m.RequiredNodeLabels) > 0 {
		for k := range m.RequiredNodeLabels {
			v := m.RequiredNodeLabels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintQueue(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x5a
		}
	}
	if len(m.Annotations) > 0 {
		for k := range m.Annotations {
			v := m.Annotations[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintQueue(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintQueue(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.Owner) > 0 {
		i -= len(m.Owner)
		copy(dAtA[i:], m.Owner)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Owner)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x3a
	}
	n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Created, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Created):])
	if err1 != nil {
		return 0, err1
	}
	i -= n1
	i = encodeVarintQueue(dAtA, i, uint64(n1))
	i--
	dAtA[i] = 0x32
	if m.PodSpec != nil {
		{
			size, err := m.PodSpec.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if m.Priority != 0 {
		i -= 8
		encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Priority))))
		i--
		dAtA[i] = 0x21
	}
	if len(m.Queue) > 0 {
		i -= len(m.Queue)
		copy(dAtA[i:], m.Queue)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Queue)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.JobSetId) > 0 {
		i -= len(m.JobSetId)
		copy(dAtA[i:], m.JobSetId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.JobSetId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StreamingLeaseRequest) 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 *StreamingLeaseRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StreamingLeaseRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ReceivedJobIds) > 0 {
		for iNdEx := len(m.ReceivedJobIds) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ReceivedJobIds[iNdEx])
			copy(dAtA[i:], m.ReceivedJobIds[iNdEx])
			i = encodeVarintQueue(dAtA, i, uint64(len(m.ReceivedJobIds[iNdEx])))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.Nodes) > 0 {
		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.MinimumJobSize) > 0 {
		for k := range m.MinimumJobSize {
			v := m.MinimumJobSize[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	{
		size, err := m.ClusterLeasedReport.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintQueue(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Resources) > 0 {
		for k := range m.Resources {
			v := m.Resources[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Pool) > 0 {
		i -= len(m.Pool)
		copy(dAtA[i:], m.Pool)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Pool)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ClusterId) > 0 {
		i -= len(m.ClusterId)
		copy(dAtA[i:], m.ClusterId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.ClusterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NodeInfo) 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 *NodeInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NodeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Unschedulable {
		i--
		if m.Unschedulable {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if len(m.NonArmadaAllocatedResources) > 0 {
		for k := range m.NonArmadaAllocatedResources {
			v := m.NonArmadaAllocatedResources[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintQueue(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4a
		}
	}
	if len(m.RunIdsByState) > 0 {
		for k := range m.RunIdsByState {
			v := m.RunIdsByState[k]
			baseI := i
			i = encodeVarintQueue(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x42
		}
	}
	if len(m.AllocatedResources) > 0 {
		for k := range m.AllocatedResources {
			v := m.AllocatedResources[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintQueue(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if len(m.TotalResources) > 0 {
		for k := range m.TotalResources {
			v := m.TotalResources[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.AvailableResources) > 0 {
		for k := range m.AvailableResources {
			v := m.AvailableResources[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.AllocatableResources) > 0 {
		for k := range m.AllocatableResources {
			v := m.AllocatableResources[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintQueue(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Taints) > 0 {
		for iNdEx := len(m.Taints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Taints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *NodeType) 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 *NodeType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *NodeType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.AllocatableResources) > 0 {
		for k := range m.AllocatableResources {
			v := m.AllocatableResources[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintQueue(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Taints) > 0 {
		for iNdEx := len(m.Taints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Taints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ClusterSchedulingInfoReport) 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 *ClusterSchedulingInfoReport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClusterSchedulingInfoReport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Pool) > 0 {
		i -= len(m.Pool)
		copy(dAtA[i:], m.Pool)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Pool)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.MinimumJobSize) > 0 {
		for k := range m.MinimumJobSize {
			v := m.MinimumJobSize[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.NodeTypes) > 0 {
		for iNdEx := len(m.NodeTypes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.NodeTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	n13, err13 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ReportTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ReportTime):])
	if err13 != nil {
		return 0, err13
	}
	i -= n13
	i = encodeVarintQueue(dAtA, i, uint64(n13))
	i--
	dAtA[i] = 0x12
	if len(m.ClusterId) > 0 {
		i -= len(m.ClusterId)
		copy(dAtA[i:], m.ClusterId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.ClusterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *QueueLeasedReport) 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 *QueueLeasedReport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *QueueLeasedReport) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ResourcesLeasedByPriority) > 0 {
		for k := range m.ResourcesLeasedByPriority {
			v := m.ResourcesLeasedByPriority[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i = encodeVarintQueue(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ResourcesLeased) > 0 {
		for k := range m.ResourcesLeased {
			v := m.ResourcesLeased[k]
			baseI := i
			{
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ClusterLeasedReport) 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 *ClusterLeasedReport) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ClusterLeasedReport) 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-- {
			{
				size, err := m.Queues[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	n16, err16 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ReportTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ReportTime):])
	if err16 != nil {
		return 0, err16
	}
	i -= n16
	i = encodeVarintQueue(dAtA, i, uint64(n16))
	i--
	dAtA[i] = 0x12
	if len(m.ClusterId) > 0 {
		i -= len(m.ClusterId)
		copy(dAtA[i:], m.ClusterId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.ClusterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ComputeResource) 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 *ComputeResource) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *NodeLabeling) 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 *NodeLabeling) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *JobLease) 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 *JobLease) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *JobLease) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Job) > 0 {
		for iNdEx := len(m.Job) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Job[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *StreamingJobLease) 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 *StreamingJobLease) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StreamingJobLease) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.NumAcked != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.NumAcked))
		i--
		dAtA[i] = 0x18
	}
	if m.NumJobs != 0 {
		i = encodeVarintQueue(dAtA, i, uint64(m.NumJobs))
		i--
		dAtA[i] = 0x10
	}
	if m.Job != nil {
		{
			size, err := m.Job.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *IdList) 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 *IdList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *RenewLeaseRequest) 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 *RenewLeaseRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

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

func (m *ReturnLeaseRequest) 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 *ReturnLeaseRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ReturnLeaseRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.TrackedAnnotations) > 0 {
		for k := range m.TrackedAnnotations {
			v := m.TrackedAnnotations[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintQueue(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintQueue(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintQueue(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x42
		}
	}
	if m.JobRunAttempted {
		i--
		if m.JobRunAttempted {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if len(m.KubernetesId) > 0 {
		i -= len(m.KubernetesId)
		copy(dAtA[i:], m.KubernetesId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.KubernetesId)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Reason) > 0 {
		i -= len(m.Reason)
		copy(dAtA[i:], m.Reason)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Reason)))
		i--
		dAtA[i] = 0x2a
	}
	if m.AvoidNodeLabels != nil {
		{
			size, err := m.AvoidNodeLabels.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintQueue(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.JobId) > 0 {
		i -= len(m.JobId)
		copy(dAtA[i:], m.JobId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.JobId)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.ClusterId) > 0 {
		i -= len(m.ClusterId)
		copy(dAtA[i:], m.ClusterId)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.ClusterId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *StringKeyValuePair) 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 *StringKeyValuePair) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StringKeyValuePair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintQueue(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *OrderedStringMap) 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 *OrderedStringMap) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *OrderedStringMap) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintQueue(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintQueue(dAtA []byte, offset int, v uint64) int {
	offset -= sovQueue(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Job) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.JobSetId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.Queue)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.Priority != 0 {
		n += 9
	}
	if m.PodSpec != nil {
		l = m.PodSpec.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.Created)
	n += 1 + l + sovQueue(uint64(l))
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.Owner)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + len(v) + sovQueue(uint64(len(v)))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.Annotations) > 0 {
		for k, v := range m.Annotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + len(v) + sovQueue(uint64(len(v)))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.RequiredNodeLabels) > 0 {
		for k, v := range m.RequiredNodeLabels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + len(v) + sovQueue(uint64(len(v)))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.PodSpecs) > 0 {
		for _, e := range m.PodSpecs {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	l = len(m.ClientId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if len(m.Ingress) > 0 {
		for _, e := range m.Ingress {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if len(m.QueueOwnershipUserGroups) > 0 {
		for _, s := range m.QueueOwnershipUserGroups {
			l = len(s)
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if len(m.Services) > 0 {
		for _, e := range m.Services {
			l = e.Size()
			n += 2 + l + sovQueue(uint64(l))
		}
	}
	if len(m.K8SIngress) > 0 {
		for _, e := range m.K8SIngress {
			l = e.Size()
			n += 2 + l + sovQueue(uint64(l))
		}
	}
	if len(m.K8SService) > 0 {
		for _, e := range m.K8SService {
			l = e.Size()
			n += 2 + l + sovQueue(uint64(l))
		}
	}
	l = len(m.CompressedQueueOwnershipUserGroups)
	if l > 0 {
		n += 2 + l + sovQueue(uint64(l))
	}
	l = len(m.Scheduler)
	if l > 0 {
		n += 2 + l + sovQueue(uint64(l))
	}
	return n
}

func (m *StreamingLeaseRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.Pool)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if len(m.Resources) > 0 {
		for k, v := range m.Resources {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	l = m.ClusterLeasedReport.Size()
	n += 1 + l + sovQueue(uint64(l))
	if len(m.MinimumJobSize) > 0 {
		for k, v := range m.MinimumJobSize {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.Nodes) > 0 {
		for _, e := range m.Nodes {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if len(m.ReceivedJobIds) > 0 {
		for _, s := range m.ReceivedJobIds {
			l = len(s)
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	return n
}

func (m *NodeInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if len(m.Taints) > 0 {
		for _, e := range m.Taints {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + len(v) + sovQueue(uint64(len(v)))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.AllocatableResources) > 0 {
		for k, v := range m.AllocatableResources {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.AvailableResources) > 0 {
		for k, v := range m.AvailableResources {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.TotalResources) > 0 {
		for k, v := range m.TotalResources {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.AllocatedResources) > 0 {
		for k, v := range m.AllocatedResources {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovQueue(uint64(k)) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.RunIdsByState) > 0 {
		for k, v := range m.RunIdsByState {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + sovQueue(uint64(v))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.NonArmadaAllocatedResources) > 0 {
		for k, v := range m.NonArmadaAllocatedResources {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovQueue(uint64(k)) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if m.Unschedulable {
		n += 2
	}
	return n
}

func (m *NodeType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Taints) > 0 {
		for _, e := range m.Taints {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + len(v) + sovQueue(uint64(len(v)))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.AllocatableResources) > 0 {
		for k, v := range m.AllocatableResources {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ClusterSchedulingInfoReport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ReportTime)
	n += 1 + l + sovQueue(uint64(l))
	if len(m.NodeTypes) > 0 {
		for _, e := range m.NodeTypes {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	if len(m.MinimumJobSize) > 0 {
		for k, v := range m.MinimumJobSize {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	l = len(m.Pool)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}

func (m *QueueLeasedReport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if len(m.ResourcesLeased) > 0 {
		for k, v := range m.ResourcesLeased {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	if len(m.ResourcesLeasedByPriority) > 0 {
		for k, v := range m.ResourcesLeasedByPriority {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + sovQueue(uint64(k)) + 1 + l + sovQueue(uint64(l))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ClusterLeasedReport) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.ReportTime)
	n += 1 + l + sovQueue(uint64(l))
	if len(m.Queues) > 0 {
		for _, e := range m.Queues {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	return n
}

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

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

func (m *JobLease) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Job) > 0 {
		for _, e := range m.Job {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	return n
}

func (m *StreamingJobLease) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Job != nil {
		l = m.Job.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.NumJobs != 0 {
		n += 1 + sovQueue(uint64(m.NumJobs))
	}
	if m.NumAcked != 0 {
		n += 1 + sovQueue(uint64(m.NumAcked))
	}
	return n
}

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

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

func (m *ReturnLeaseRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ClusterId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.JobId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.AvoidNodeLabels != nil {
		l = m.AvoidNodeLabels.Size()
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.Reason)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.KubernetesId)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	if m.JobRunAttempted {
		n += 2
	}
	if len(m.TrackedAnnotations) > 0 {
		for k, v := range m.TrackedAnnotations {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovQueue(uint64(len(k))) + 1 + len(v) + sovQueue(uint64(len(v)))
			n += mapEntrySize + 1 + sovQueue(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *StringKeyValuePair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovQueue(uint64(l))
	}
	return n
}

func (m *OrderedStringMap) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovQueue(uint64(l))
		}
	}
	return n
}

func sovQueue(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozQueue(x uint64) (n int) {
	return sovQueue(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Job) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForPodSpecs := "[]*PodSpec{"
	for _, f := range this.PodSpecs {
		repeatedStringForPodSpecs += strings.Replace(fmt.Sprintf("%v", f), "PodSpec", "v1.PodSpec", 1) + ","
	}
	repeatedStringForPodSpecs += "}"
	repeatedStringForIngress := "[]*IngressConfig{"
	for _, f := range this.Ingress {
		repeatedStringForIngress += strings.Replace(fmt.Sprintf("%v", f), "IngressConfig", "IngressConfig", 1) + ","
	}
	repeatedStringForIngress += "}"
	repeatedStringForServices := "[]*ServiceConfig{"
	for _, f := range this.Services {
		repeatedStringForServices += strings.Replace(fmt.Sprintf("%v", f), "ServiceConfig", "ServiceConfig", 1) + ","
	}
	repeatedStringForServices += "}"
	repeatedStringForK8SIngress := "[]*Ingress{"
	for _, f := range this.K8SIngress {
		repeatedStringForK8SIngress += strings.Replace(fmt.Sprintf("%v", f), "Ingress", "v11.Ingress", 1) + ","
	}
	repeatedStringForK8SIngress += "}"
	repeatedStringForK8SService := "[]*Service{"
	for _, f := range this.K8SService {
		repeatedStringForK8SService += strings.Replace(fmt.Sprintf("%v", f), "Service", "v1.Service", 1) + ","
	}
	repeatedStringForK8SService += "}"
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	keysForAnnotations := make([]string, 0, len(this.Annotations))
	for k, _ := range this.Annotations {
		keysForAnnotations = append(keysForAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations)
	mapStringForAnnotations := "map[string]string{"
	for _, k := range keysForAnnotations {
		mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k])
	}
	mapStringForAnnotations += "}"
	keysForRequiredNodeLabels := make([]string, 0, len(this.RequiredNodeLabels))
	for k, _ := range this.RequiredNodeLabels {
		keysForRequiredNodeLabels = append(keysForRequiredNodeLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRequiredNodeLabels)
	mapStringForRequiredNodeLabels := "map[string]string{"
	for _, k := range keysForRequiredNodeLabels {
		mapStringForRequiredNodeLabels += fmt.Sprintf("%v: %v,", k, this.RequiredNodeLabels[k])
	}
	mapStringForRequiredNodeLabels += "}"
	s := strings.Join([]string{`&Job{`,
		`Id:` + fmt.Sprintf("%v", this.Id) + `,`,
		`JobSetId:` + fmt.Sprintf("%v", this.JobSetId) + `,`,
		`Queue:` + fmt.Sprintf("%v", this.Queue) + `,`,
		`Priority:` + fmt.Sprintf("%v", this.Priority) + `,`,
		`PodSpec:` + strings.Replace(fmt.Sprintf("%v", this.PodSpec), "PodSpec", "v1.PodSpec", 1) + `,`,
		`Created:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.Created), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`,
		`Owner:` + fmt.Sprintf("%v", this.Owner) + `,`,
		`Labels:` + mapStringForLabels + `,`,
		`Annotations:` + mapStringForAnnotations + `,`,
		`RequiredNodeLabels:` + mapStringForRequiredNodeLabels + `,`,
		`PodSpecs:` + repeatedStringForPodSpecs + `,`,
		`ClientId:` + fmt.Sprintf("%v", this.ClientId) + `,`,
		`Ingress:` + repeatedStringForIngress + `,`,
		`QueueOwnershipUserGroups:` + fmt.Sprintf("%v", this.QueueOwnershipUserGroups) + `,`,
		`Services:` + repeatedStringForServices + `,`,
		`K8SIngress:` + repeatedStringForK8SIngress + `,`,
		`K8SService:` + repeatedStringForK8SService + `,`,
		`CompressedQueueOwnershipUserGroups:` + fmt.Sprintf("%v", this.CompressedQueueOwnershipUserGroups) + `,`,
		`Scheduler:` + fmt.Sprintf("%v", this.Scheduler) + `,`,
		`}`,
	}, "")
	return s
}
func (this *StreamingLeaseRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForNodes := "[]NodeInfo{"
	for _, f := range this.Nodes {
		repeatedStringForNodes += strings.Replace(strings.Replace(f.String(), "NodeInfo", "NodeInfo", 1), `&`, ``, 1) + ","
	}
	repeatedStringForNodes += "}"
	keysForResources := make([]string, 0, len(this.Resources))
	for k, _ := range this.Resources {
		keysForResources = append(keysForResources, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForResources)
	mapStringForResources := "map[string]resource.Quantity{"
	for _, k := range keysForResources {
		mapStringForResources += fmt.Sprintf("%v: %v,", k, this.Resources[k])
	}
	mapStringForResources += "}"
	keysForMinimumJobSize := make([]string, 0, len(this.MinimumJobSize))
	for k, _ := range this.MinimumJobSize {
		keysForMinimumJobSize = append(keysForMinimumJobSize, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMinimumJobSize)
	mapStringForMinimumJobSize := "map[string]resource.Quantity{"
	for _, k := range keysForMinimumJobSize {
		mapStringForMinimumJobSize += fmt.Sprintf("%v: %v,", k, this.MinimumJobSize[k])
	}
	mapStringForMinimumJobSize += "}"
	s := strings.Join([]string{`&StreamingLeaseRequest{`,
		`ClusterId:` + fmt.Sprintf("%v", this.ClusterId) + `,`,
		`Pool:` + fmt.Sprintf("%v", this.Pool) + `,`,
		`Resources:` + mapStringForResources + `,`,
		`ClusterLeasedReport:` + strings.Replace(strings.Replace(this.ClusterLeasedReport.String(), "ClusterLeasedReport", "ClusterLeasedReport", 1), `&`, ``, 1) + `,`,
		`MinimumJobSize:` + mapStringForMinimumJobSize + `,`,
		`Nodes:` + repeatedStringForNodes + `,`,
		`ReceivedJobIds:` + fmt.Sprintf("%v", this.ReceivedJobIds) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NodeInfo) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTaints := "[]Taint{"
	for _, f := range this.Taints {
		repeatedStringForTaints += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForTaints += "}"
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	keysForAllocatableResources := make([]string, 0, len(this.AllocatableResources))
	for k, _ := range this.AllocatableResources {
		keysForAllocatableResources = append(keysForAllocatableResources, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAllocatableResources)
	mapStringForAllocatableResources := "map[string]resource.Quantity{"
	for _, k := range keysForAllocatableResources {
		mapStringForAllocatableResources += fmt.Sprintf("%v: %v,", k, this.AllocatableResources[k])
	}
	mapStringForAllocatableResources += "}"
	keysForAvailableResources := make([]string, 0, len(this.AvailableResources))
	for k, _ := range this.AvailableResources {
		keysForAvailableResources = append(keysForAvailableResources, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAvailableResources)
	mapStringForAvailableResources := "map[string]resource.Quantity{"
	for _, k := range keysForAvailableResources {
		mapStringForAvailableResources += fmt.Sprintf("%v: %v,", k, this.AvailableResources[k])
	}
	mapStringForAvailableResources += "}"
	keysForTotalResources := make([]string, 0, len(this.TotalResources))
	for k, _ := range this.TotalResources {
		keysForTotalResources = append(keysForTotalResources, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForTotalResources)
	mapStringForTotalResources := "map[string]resource.Quantity{"
	for _, k := range keysForTotalResources {
		mapStringForTotalResources += fmt.Sprintf("%v: %v,", k, this.TotalResources[k])
	}
	mapStringForTotalResources += "}"
	keysForAllocatedResources := make([]int32, 0, len(this.AllocatedResources))
	for k, _ := range this.AllocatedResources {
		keysForAllocatedResources = append(keysForAllocatedResources, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForAllocatedResources)
	mapStringForAllocatedResources := "map[int32]ComputeResource{"
	for _, k := range keysForAllocatedResources {
		mapStringForAllocatedResources += fmt.Sprintf("%v: %v,", k, this.AllocatedResources[k])
	}
	mapStringForAllocatedResources += "}"
	keysForRunIdsByState := make([]string, 0, len(this.RunIdsByState))
	for k, _ := range this.RunIdsByState {
		keysForRunIdsByState = append(keysForRunIdsByState, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForRunIdsByState)
	mapStringForRunIdsByState := "map[string]JobState{"
	for _, k := range keysForRunIdsByState {
		mapStringForRunIdsByState += fmt.Sprintf("%v: %v,", k, this.RunIdsByState[k])
	}
	mapStringForRunIdsByState += "}"
	keysForNonArmadaAllocatedResources := make([]int32, 0, len(this.NonArmadaAllocatedResources))
	for k, _ := range this.NonArmadaAllocatedResources {
		keysForNonArmadaAllocatedResources = append(keysForNonArmadaAllocatedResources, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForNonArmadaAllocatedResources)
	mapStringForNonArmadaAllocatedResources := "map[int32]ComputeResource{"
	for _, k := range keysForNonArmadaAllocatedResources {
		mapStringForNonArmadaAllocatedResources += fmt.Sprintf("%v: %v,", k, this.NonArmadaAllocatedResources[k])
	}
	mapStringForNonArmadaAllocatedResources += "}"
	s := strings.Join([]string{`&NodeInfo{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Taints:` + repeatedStringForTaints + `,`,
		`Labels:` + mapStringForLabels + `,`,
		`AllocatableResources:` + mapStringForAllocatableResources + `,`,
		`AvailableResources:` + mapStringForAvailableResources + `,`,
		`TotalResources:` + mapStringForTotalResources + `,`,
		`AllocatedResources:` + mapStringForAllocatedResources + `,`,
		`RunIdsByState:` + mapStringForRunIdsByState + `,`,
		`NonArmadaAllocatedResources:` + mapStringForNonArmadaAllocatedResources + `,`,
		`Unschedulable:` + fmt.Sprintf("%v", this.Unschedulable) + `,`,
		`}`,
	}, "")
	return s
}
func (this *NodeType) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForTaints := "[]Taint{"
	for _, f := range this.Taints {
		repeatedStringForTaints += fmt.Sprintf("%v", f) + ","
	}
	repeatedStringForTaints += "}"
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	keysForAllocatableResources := make([]string, 0, len(this.AllocatableResources))
	for k, _ := range this.AllocatableResources {
		keysForAllocatableResources = append(keysForAllocatableResources, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForAllocatableResources)
	mapStringForAllocatableResources := "map[string]resource.Quantity{"
	for _, k := range keysForAllocatableResources {
		mapStringForAllocatableResources += fmt.Sprintf("%v: %v,", k, this.AllocatableResources[k])
	}
	mapStringForAllocatableResources += "}"
	s := strings.Join([]string{`&NodeType{`,
		`Taints:` + repeatedStringForTaints + `,`,
		`Labels:` + mapStringForLabels + `,`,
		`AllocatableResources:` + mapStringForAllocatableResources + `,`,
		`}`,
	}, "")
	return s
}
func (this *ClusterSchedulingInfoReport) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForNodeTypes := "[]*NodeType{"
	for _, f := range this.NodeTypes {
		repeatedStringForNodeTypes += strings.Replace(f.String(), "NodeType", "NodeType", 1) + ","
	}
	repeatedStringForNodeTypes += "}"
	keysForMinimumJobSize := make([]string, 0, len(this.MinimumJobSize))
	for k, _ := range this.MinimumJobSize {
		keysForMinimumJobSize = append(keysForMinimumJobSize, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMinimumJobSize)
	mapStringForMinimumJobSize := "map[string]resource.Quantity{"
	for _, k := range keysForMinimumJobSize {
		mapStringForMinimumJobSize += fmt.Sprintf("%v: %v,", k, this.MinimumJobSize[k])
	}
	mapStringForMinimumJobSize += "}"
	s := strings.Join([]string{`&ClusterSchedulingInfoReport{`,
		`ClusterId:` + fmt.Sprintf("%v", this.ClusterId) + `,`,
		`ReportTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ReportTime), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`NodeTypes:` + repeatedStringForNodeTypes + `,`,
		`MinimumJobSize:` + mapStringForMinimumJobSize + `,`,
		`Pool:` + fmt.Sprintf("%v", this.Pool) + `,`,
		`}`,
	}, "")
	return s
}
func (this *QueueLeasedReport) String() string {
	if this == nil {
		return "nil"
	}
	keysForResourcesLeased := make([]string, 0, len(this.ResourcesLeased))
	for k, _ := range this.ResourcesLeased {
		keysForResourcesLeased = append(keysForResourcesLeased, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForResourcesLeased)
	mapStringForResourcesLeased := "map[string]resource.Quantity{"
	for _, k := range keysForResourcesLeased {
		mapStringForResourcesLeased += fmt.Sprintf("%v: %v,", k, this.ResourcesLeased[k])
	}
	mapStringForResourcesLeased += "}"
	keysForResourcesLeasedByPriority := make([]int32, 0, len(this.ResourcesLeasedByPriority))
	for k, _ := range this.ResourcesLeasedByPriority {
		keysForResourcesLeasedByPriority = append(keysForResourcesLeasedByPriority, k)
	}
	github_com_gogo_protobuf_sortkeys.Int32s(keysForResourcesLeasedByPriority)
	mapStringForResourcesLeasedByPriority := "map[int32]ComputeResource{"
	for _, k := range keysForResourcesLeasedByPriority {
		mapStringForResourcesLeasedByPriority += fmt.Sprintf("%v: %v,", k, this.ResourcesLeasedByPriority[k])
	}
	mapStringForResourcesLeasedByPriority += "}"
	s := strings.Join([]string{`&QueueLeasedReport{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ResourcesLeased:` + mapStringForResourcesLeased + `,`,
		`ResourcesLeasedByPriority:` + mapStringForResourcesLeasedByPriority + `,`,
		`}`,
	}, "")
	return s
}
func (this *ClusterLeasedReport) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForQueues := "[]*QueueLeasedReport{"
	for _, f := range this.Queues {
		repeatedStringForQueues += strings.Replace(f.String(), "QueueLeasedReport", "QueueLeasedReport", 1) + ","
	}
	repeatedStringForQueues += "}"
	s := strings.Join([]string{`&ClusterLeasedReport{`,
		`ClusterId:` + fmt.Sprintf("%v", this.ClusterId) + `,`,
		`ReportTime:` + strings.Replace(strings.Replace(fmt.Sprintf("%v", this.ReportTime), "Timestamp", "types.Timestamp", 1), `&`, ``, 1) + `,`,
		`Queues:` + repeatedStringForQueues + `,`,
		`}`,
	}, "")
	return s
}
func (this *ComputeResource) String() string {
	if this == nil {
		return "nil"
	}
	keysForResources := make([]string, 0, len(this.Resources))
	for k, _ := range this.Resources {
		keysForResources = append(keysForResources, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForResources)
	mapStringForResources := "map[string]resource.Quantity{"
	for _, k := range keysForResources {
		mapStringForResources += fmt.Sprintf("%v: %v,", k, this.Resources[k])
	}
	mapStringForResources += "}"
	s := strings.Join([]string{`&ComputeResource{`,
		`Resources:` + mapStringForResources + `,`,
		`}`,
	}, "")
	return s
}
func (this *NodeLabeling) String() string {
	if this == nil {
		return "nil"
	}
	keysForLabels := make([]string, 0, len(this.Labels))
	for k, _ := range this.Labels {
		keysForLabels = append(keysForLabels, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForLabels)
	mapStringForLabels := "map[string]string{"
	for _, k := range keysForLabels {
		mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k])
	}
	mapStringForLabels += "}"
	s := strings.Join([]string{`&NodeLabeling{`,
		`Labels:` + mapStringForLabels + `,`,
		`}`,
	}, "")
	return s
}
func (this *JobLease) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForJob := "[]*Job{"
	for _, f := range this.Job {
		repeatedStringForJob += strings.Replace(f.String(), "Job", "Job", 1) + ","
	}
	repeatedStringForJob += "}"
	s := strings.Join([]string{`&JobLease{`,
		`Job:` + repeatedStringForJob + `,`,
		`}`,
	}, "")
	return s
}
func (this *StreamingJobLease) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StreamingJobLease{`,
		`Job:` + strings.Replace(this.Job.String(), "Job", "Job", 1) + `,`,
		`NumJobs:` + fmt.Sprintf("%v", this.NumJobs) + `,`,
		`NumAcked:` + fmt.Sprintf("%v", this.NumAcked) + `,`,
		`}`,
	}, "")
	return s
}
func (this *IdList) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&IdList{`,
		`Ids:` + fmt.Sprintf("%v", this.Ids) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RenewLeaseRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RenewLeaseRequest{`,
		`ClusterId:` + fmt.Sprintf("%v", this.ClusterId) + `,`,
		`Ids:` + fmt.Sprintf("%v", this.Ids) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ReturnLeaseRequest) String() string {
	if this == nil {
		return "nil"
	}
	keysForTrackedAnnotations := make([]string, 0, len(this.TrackedAnnotations))
	for k, _ := range this.TrackedAnnotations {
		keysForTrackedAnnotations = append(keysForTrackedAnnotations, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForTrackedAnnotations)
	mapStringForTrackedAnnotations := "map[string]string{"
	for _, k := range keysForTrackedAnnotations {
		mapStringForTrackedAnnotations += fmt.Sprintf("%v: %v,", k, this.TrackedAnnotations[k])
	}
	mapStringForTrackedAnnotations += "}"
	s := strings.Join([]string{`&ReturnLeaseRequest{`,
		`ClusterId:` + fmt.Sprintf("%v", this.ClusterId) + `,`,
		`JobId:` + fmt.Sprintf("%v", this.JobId) + `,`,
		`AvoidNodeLabels:` + strings.Replace(this.AvoidNodeLabels.String(), "OrderedStringMap", "OrderedStringMap", 1) + `,`,
		`Reason:` + fmt.Sprintf("%v", this.Reason) + `,`,
		`KubernetesId:` + fmt.Sprintf("%v", this.KubernetesId) + `,`,
		`JobRunAttempted:` + fmt.Sprintf("%v", this.JobRunAttempted) + `,`,
		`TrackedAnnotations:` + mapStringForTrackedAnnotations + `,`,
		`}`,
	}, "")
	return s
}
func (this *StringKeyValuePair) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&StringKeyValuePair{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`Value:` + fmt.Sprintf("%v", this.Value) + `,`,
		`}`,
	}, "")
	return s
}
func (this *OrderedStringMap) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForEntries := "[]*StringKeyValuePair{"
	for _, f := range this.Entries {
		repeatedStringForEntries += strings.Replace(f.String(), "StringKeyValuePair", "StringKeyValuePair", 1) + ","
	}
	repeatedStringForEntries += "}"
	s := strings.Join([]string{`&OrderedStringMap{`,
		`Entries:` + repeatedStringForEntries + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringQueue(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Job) 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 ErrIntOverflowQueue
			}
			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: Job: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Job: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobSetId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobSetId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Queue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field Priority", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.Priority = float64(math.Float64frombits(v))
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodSpec", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.PodSpec == nil {
				m.PodSpec = &v1.PodSpec{}
			}
			if err := m.PodSpec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Created", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.Created, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			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 ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Owner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = 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 ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Annotations == nil {
				m.Annotations = 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 ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Annotations[mapkey] = mapvalue
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RequiredNodeLabels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RequiredNodeLabels == nil {
				m.RequiredNodeLabels = 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 ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RequiredNodeLabels[mapkey] = mapvalue
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodSpecs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodSpecs = append(m.PodSpecs, &v1.PodSpec{})
			if err := m.PodSpecs[len(m.PodSpecs)-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 ClientId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClientId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ingress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ingress = append(m.Ingress, &IngressConfig{})
			if err := m.Ingress[len(m.Ingress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueOwnershipUserGroups", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueueOwnershipUserGroups = append(m.QueueOwnershipUserGroups, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Services", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Services = append(m.Services, &ServiceConfig{})
			if err := m.Services[len(m.Services)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field K8SIngress", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.K8SIngress = append(m.K8SIngress, &v11.Ingress{})
			if err := m.K8SIngress[len(m.K8SIngress)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field K8SService", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.K8SService = append(m.K8SService, &v1.Service{})
			if err := m.K8SService[len(m.K8SService)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompressedQueueOwnershipUserGroups", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CompressedQueueOwnershipUserGroups = append(m.CompressedQueueOwnershipUserGroups[:0], dAtA[iNdEx:postIndex]...)
			if m.CompressedQueueOwnershipUserGroups == nil {
				m.CompressedQueueOwnershipUserGroups = []byte{}
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Scheduler", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Scheduler = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StreamingLeaseRequest) 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 ErrIntOverflowQueue
			}
			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: StreamingLeaseRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamingLeaseRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pool = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Resources == nil {
				m.Resources = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Resources[mapkey] = *mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterLeasedReport", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ClusterLeasedReport.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinimumJobSize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MinimumJobSize == nil {
				m.MinimumJobSize = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MinimumJobSize[mapkey] = *mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nodes = append(m.Nodes, NodeInfo{})
			if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReceivedJobIds", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReceivedJobIds = append(m.ReceivedJobIds, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeInfo) 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 ErrIntOverflowQueue
			}
			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: NodeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Taints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Taints = append(m.Taints, v1.Taint{})
			if err := m.Taints[len(m.Taints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = 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 ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllocatableResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AllocatableResources == nil {
				m.AllocatableResources = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.AllocatableResources[mapkey] = *mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvailableResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AvailableResources == nil {
				m.AvailableResources = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.AvailableResources[mapkey] = *mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TotalResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TotalResources == nil {
				m.TotalResources = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.TotalResources[mapkey] = *mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllocatedResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AllocatedResources == nil {
				m.AllocatedResources = make(map[int32]ComputeResource)
			}
			var mapkey int32
			mapvalue := &ComputeResource{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ComputeResource{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.AllocatedResources[mapkey] = *mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RunIdsByState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RunIdsByState == nil {
				m.RunIdsByState = 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 ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= JobState(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.RunIdsByState[mapkey] = mapvalue
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NonArmadaAllocatedResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.NonArmadaAllocatedResources == nil {
				m.NonArmadaAllocatedResources = make(map[int32]ComputeResource)
			}
			var mapkey int32
			mapvalue := &ComputeResource{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ComputeResource{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.NonArmadaAllocatedResources[mapkey] = *mapvalue
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unschedulable", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Unschedulable = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeType) 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 ErrIntOverflowQueue
			}
			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: NodeType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Taints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Taints = append(m.Taints, v1.Taint{})
			if err := m.Taints[len(m.Taints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = 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 ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AllocatableResources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AllocatableResources == nil {
				m.AllocatableResources = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.AllocatableResources[mapkey] = *mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClusterSchedulingInfoReport) 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 ErrIntOverflowQueue
			}
			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: ClusterSchedulingInfoReport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterSchedulingInfoReport: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ReportTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeTypes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeTypes = append(m.NodeTypes, &NodeType{})
			if err := m.NodeTypes[len(m.NodeTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MinimumJobSize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MinimumJobSize == nil {
				m.MinimumJobSize = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MinimumJobSize[mapkey] = *mapvalue
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Pool", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Pool = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *QueueLeasedReport) 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 ErrIntOverflowQueue
			}
			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: QueueLeasedReport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: QueueLeasedReport: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourcesLeased", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ResourcesLeased == nil {
				m.ResourcesLeased = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ResourcesLeased[mapkey] = *mapvalue
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourcesLeasedByPriority", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ResourcesLeasedByPriority == nil {
				m.ResourcesLeasedByPriority = make(map[int32]ComputeResource)
			}
			var mapkey int32
			mapvalue := &ComputeResource{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= int32(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &ComputeResource{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.ResourcesLeasedByPriority[mapkey] = *mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ClusterLeasedReport) 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 ErrIntOverflowQueue
			}
			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: ClusterLeasedReport: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterLeasedReport: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReportTime", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.ReportTime, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Queues", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Queues = append(m.Queues, &QueueLeasedReport{})
			if err := m.Queues[len(m.Queues)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ComputeResource) 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 ErrIntOverflowQueue
			}
			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: ComputeResource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ComputeResource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Resources == nil {
				m.Resources = make(map[string]resource.Quantity)
			}
			var mapkey string
			mapvalue := &resource.Quantity{}
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthQueue
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthQueue
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &resource.Quantity{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Resources[mapkey] = *mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *NodeLabeling) 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 ErrIntOverflowQueue
			}
			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: NodeLabeling: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeLabeling: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = 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 ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *JobLease) 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 ErrIntOverflowQueue
			}
			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: JobLease: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: JobLease: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Job", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Job = append(m.Job, &Job{})
			if err := m.Job[len(m.Job)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StreamingJobLease) 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 ErrIntOverflowQueue
			}
			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: StreamingJobLease: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StreamingJobLease: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Job", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Job == nil {
				m.Job = &Job{}
			}
			if err := m.Job.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumJobs", wireType)
			}
			m.NumJobs = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumJobs |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NumAcked", wireType)
			}
			m.NumAcked = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NumAcked |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *IdList) 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 ErrIntOverflowQueue
			}
			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: IdList: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: IdList: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RenewLeaseRequest) 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 ErrIntOverflowQueue
			}
			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: RenewLeaseRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RenewLeaseRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ids", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Ids = append(m.Ids, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ReturnLeaseRequest) 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 ErrIntOverflowQueue
			}
			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: ReturnLeaseRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReturnLeaseRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterId = 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 ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.JobId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AvoidNodeLabels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AvoidNodeLabels == nil {
				m.AvoidNodeLabels = &OrderedStringMap{}
			}
			if err := m.AvoidNodeLabels.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Reason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KubernetesId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.KubernetesId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field JobRunAttempted", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.JobRunAttempted = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrackedAnnotations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TrackedAnnotations == nil {
				m.TrackedAnnotations = 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 ErrIntOverflowQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthQueue
					}
					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 ErrIntOverflowQueue
						}
						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 ErrInvalidLengthQueue
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthQueue
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipQueue(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthQueue
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.TrackedAnnotations[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StringKeyValuePair) 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 ErrIntOverflowQueue
			}
			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: StringKeyValuePair: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StringKeyValuePair: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				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 ErrInvalidLengthQueue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Value = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *OrderedStringMap) 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 ErrIntOverflowQueue
			}
			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: OrderedStringMap: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: OrderedStringMap: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowQueue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthQueue
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthQueue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, &StringKeyValuePair{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipQueue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthQueue
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipQueue(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, ErrIntOverflowQueue
			}
			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, ErrIntOverflowQueue
				}
				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, ErrIntOverflowQueue
				}
				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, ErrInvalidLengthQueue
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupQueue
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthQueue
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthQueue        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowQueue          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupQueue = fmt.Errorf("proto: unexpected end of group")
)