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"
	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"`
	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"`
	Ingress                  []*IngressConfig  `protobuf:"bytes,14,rep,name=ingress,proto3" json:"ingress,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) 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
}

type LeaseRequest struct {
	ClusterId           string                       `protobuf:"bytes,1,opt,name=cluster_id,json=clusterId,proto3" json:"clusterId,omitempty"`
	Pool                string                       `protobuf:"bytes,8,opt,name=pool,proto3" json:"pool,omitempty"`
	Resources           map[string]resource.Quantity `protobuf:"bytes,2,rep,name=resources,proto3" json:"resources" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ClusterLeasedReport ClusterLeasedReport          `protobuf:"bytes,4,opt,name=cluster_leased_report,json=clusterLeasedReport,proto3" json:"cluster_leased_report"`
	MinimumJobSize      map[string]resource.Quantity `protobuf:"bytes,6,rep,name=minimum_job_size,json=minimumJobSize,proto3" json:"minimumJobSize,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Nodes               []NodeInfo                   `protobuf:"bytes,7,rep,name=nodes,proto3" json:"nodes"`
}

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

var xxx_messageInfo_LeaseRequest proto.InternalMessageInfo

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

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

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

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

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

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

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"`
	AllocatableResources map[string]resource.Quantity `protobuf:"bytes,4,rep,name=allocatable_resources,json=allocatableResources,proto3" json:"allocatableResources,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	AvailableResources   map[string]resource.Quantity `protobuf:"bytes,5,rep,name=available_resources,json=availableResources,proto3" json:"availableResources,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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
}

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,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:"report_time"`
	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,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 {
	Name            string                       `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ResourcesLeased map[string]resource.Quantity `protobuf:"bytes,2,rep,name=resources_leased,json=resourcesLeased,proto3" json:"resourcesLeased,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
}

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:"report_time"`
	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 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{10}
}
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{11}
}
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"`
}

func (m *ReturnLeaseRequest) Reset()      { *m = ReturnLeaseRequest{} }
func (*ReturnLeaseRequest) ProtoMessage() {}
func (*ReturnLeaseRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_d92c0c680df9617a, []int{12}
}
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
}

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

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

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

// 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 {
	LeaseJobs(ctx context.Context, in *LeaseRequest, opts ...grpc.CallOption) (*JobLease, 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) LeaseJobs(ctx context.Context, in *LeaseRequest, opts ...grpc.CallOption) (*JobLease, error) {
	out := new(JobLease)
	err := c.cc.Invoke(ctx, "/api.AggregatedQueue/LeaseJobs", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, 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 {
	LeaseJobs(context.Context, *LeaseRequest) (*JobLease, 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) LeaseJobs(ctx context.Context, req *LeaseRequest) (*JobLease, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LeaseJobs 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_LeaseJobs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LeaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(AggregatedQueueServer).LeaseJobs(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/api.AggregatedQueue/LeaseJobs",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(AggregatedQueueServer).LeaseJobs(ctx, req.(*LeaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

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: "LeaseJobs",
			Handler:    _AggregatedQueue_LeaseJobs_Handler,
		},
		{
			MethodName: "RenewLease",
			Handler:    _AggregatedQueue_RenewLease_Handler,
		},
		{
			MethodName: "ReturnLease",
			Handler:    _AggregatedQueue_ReturnLease_Handler,
		},
		{
			MethodName: "ReportDone",
			Handler:    _AggregatedQueue_ReportDone_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	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.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 *LeaseRequest) 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 *LeaseRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LeaseRequest) 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] = 0x42
	}
	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] = 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
		}
	}
	{
		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] = 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 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
		}
	}
	n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ReportTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ReportTime):])
	if err10 != nil {
		return 0, err10
	}
	i -= n10
	i = encodeVarintQueue(dAtA, i, uint64(n10))
	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.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
		}
	}
	n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.ReportTime, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.ReportTime):])
	if err12 != nil {
		return 0, err12
	}
	i -= n12
	i = encodeVarintQueue(dAtA, i, uint64(n12))
	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 *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 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))
		}
	}
	return n
}

func (m *LeaseRequest) 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.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))
		}
	}
	l = len(m.Pool)
	if l > 0 {
		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))
		}
	}
	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))
		}
	}
	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 *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))
	}
	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 += "}"
	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) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LeaseRequest) 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{`&LeaseRequest{`,
		`ClusterId:` + fmt.Sprintf("%v", this.ClusterId) + `,`,
		`Resources:` + mapStringForResources + `,`,
		`ClusterLeasedReport:` + strings.Replace(strings.Replace(this.ClusterLeasedReport.String(), "ClusterLeasedReport", "ClusterLeasedReport", 1), `&`, ``, 1) + `,`,
		`MinimumJobSize:` + mapStringForMinimumJobSize + `,`,
		`Nodes:` + repeatedStringForNodes + `,`,
		`Pool:` + fmt.Sprintf("%v", this.Pool) + `,`,
		`}`,
	}, "")
	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 += "}"
	s := strings.Join([]string{`&NodeInfo{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`Taints:` + repeatedStringForTaints + `,`,
		`Labels:` + mapStringForLabels + `,`,
		`AllocatableResources:` + mapStringForAllocatableResources + `,`,
		`AvailableResources:` + mapStringForAvailableResources + `,`,
		`}`,
	}, "")
	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 += "}"
	s := strings.Join([]string{`&QueueLeasedReport{`,
		`Name:` + fmt.Sprintf("%v", this.Name) + `,`,
		`ResourcesLeased:` + mapStringForResourcesLeased + `,`,
		`}`,
	}, "")
	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 *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"
	}
	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) + `,`,
		`}`,
	}, "")
	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
		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 *LeaseRequest) 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: LeaseRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LeaseRequest: 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 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 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 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 8:
			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 *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
		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
		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 *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
		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")
)