// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: task.proto

package models

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
	io "io"
	math "math"
	math_bits "math/bits"
	reflect "reflect"
	strconv "strconv"
	strings "strings"
)

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

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

type Task_State int32

const (
	Task_Invalid   Task_State = 0
	Task_Pending   Task_State = 1
	Task_Running   Task_State = 2
	Task_Completed Task_State = 3
	Task_Resolving Task_State = 4
)

var Task_State_name = map[int32]string{
	0: "Invalid",
	1: "Pending",
	2: "Running",
	3: "Completed",
	4: "Resolving",
}

var Task_State_value = map[string]int32{
	"Invalid":   0,
	"Pending":   1,
	"Running":   2,
	"Completed": 3,
	"Resolving": 4,
}

func (Task_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ce5d8dd45b4a91ff, []int{1, 0}
}

type TaskDefinition struct {
	RootFs                        string                     `protobuf:"bytes,1,opt,name=root_fs,json=rootFs,proto3" json:"rootfs"`
	EnvironmentVariables          []*EnvironmentVariable     `protobuf:"bytes,2,rep,name=environment_variables,json=environmentVariables,proto3" json:"env,omitempty"`
	Action                        *Action                    `protobuf:"bytes,3,opt,name=action,proto3" json:"action,omitempty"`
	DiskMb                        int32                      `protobuf:"varint,4,opt,name=disk_mb,json=diskMb,proto3" json:"disk_mb"`
	MemoryMb                      int32                      `protobuf:"varint,5,opt,name=memory_mb,json=memoryMb,proto3" json:"memory_mb"`
	CpuWeight                     uint32                     `protobuf:"varint,6,opt,name=cpu_weight,json=cpuWeight,proto3" json:"cpu_weight"`
	Privileged                    bool                       `protobuf:"varint,7,opt,name=privileged,proto3" json:"privileged"`
	LogSource                     string                     `protobuf:"bytes,8,opt,name=log_source,json=logSource,proto3" json:"log_source"`
	LogGuid                       string                     `protobuf:"bytes,9,opt,name=log_guid,json=logGuid,proto3" json:"log_guid"`
	MetricsGuid                   string                     `protobuf:"bytes,10,opt,name=metrics_guid,json=metricsGuid,proto3" json:"metrics_guid"`
	ResultFile                    string                     `protobuf:"bytes,11,opt,name=result_file,json=resultFile,proto3" json:"result_file"`
	CompletionCallbackUrl         string                     `protobuf:"bytes,12,opt,name=completion_callback_url,json=completionCallbackUrl,proto3" json:"completion_callback_url,omitempty"`
	Annotation                    string                     `protobuf:"bytes,13,opt,name=annotation,proto3" json:"annotation,omitempty"`
	EgressRules                   []*SecurityGroupRule       `protobuf:"bytes,14,rep,name=egress_rules,json=egressRules,proto3" json:"egress_rules,omitempty"`
	CachedDependencies            []*CachedDependency        `protobuf:"bytes,15,rep,name=cached_dependencies,json=cachedDependencies,proto3" json:"cached_dependencies,omitempty"`
	LegacyDownloadUser            string                     `protobuf:"bytes,16,opt,name=legacy_download_user,json=legacyDownloadUser,proto3" json:"legacy_download_user,omitempty"` // Deprecated: Do not use.
	TrustedSystemCertificatesPath string                     `protobuf:"bytes,17,opt,name=trusted_system_certificates_path,json=trustedSystemCertificatesPath,proto3" json:"trusted_system_certificates_path,omitempty"`
	VolumeMounts                  []*VolumeMount             `protobuf:"bytes,18,rep,name=volume_mounts,json=volumeMounts,proto3" json:"volume_mounts,omitempty"`
	Network                       *Network                   `protobuf:"bytes,19,opt,name=network,proto3" json:"network,omitempty"`
	PlacementTags                 []string                   `protobuf:"bytes,20,rep,name=placement_tags,json=placementTags,proto3" json:"placement_tags,omitempty"`
	MaxPids                       int32                      `protobuf:"varint,21,opt,name=max_pids,json=maxPids,proto3" json:"max_pids"`
	CertificateProperties         *CertificateProperties     `protobuf:"bytes,22,opt,name=certificate_properties,json=certificateProperties,proto3" json:"certificate_properties,omitempty"`
	ImageUsername                 string                     `protobuf:"bytes,23,opt,name=image_username,json=imageUsername,proto3" json:"image_username"`
	ImagePassword                 string                     `protobuf:"bytes,24,opt,name=image_password,json=imagePassword,proto3" json:"image_password"`
	ImageLayers                   []*ImageLayer              `protobuf:"bytes,25,rep,name=image_layers,json=imageLayers,proto3" json:"image_layers,omitempty"`
	LogRateLimit                  *LogRateLimit              `protobuf:"bytes,26,opt,name=log_rate_limit,json=logRateLimit,proto3" json:"log_rate_limit,omitempty"`
	MetricTags                    map[string]*MetricTagValue `protobuf:"bytes,27,rep,name=metric_tags,json=metricTags,proto3" json:"metric_tags,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_TaskDefinition proto.InternalMessageInfo

func (m *TaskDefinition) GetRootFs() string {
	if m != nil {
		return m.RootFs
	}
	return ""
}

func (m *TaskDefinition) GetEnvironmentVariables() []*EnvironmentVariable {
	if m != nil {
		return m.EnvironmentVariables
	}
	return nil
}

func (m *TaskDefinition) GetAction() *Action {
	if m != nil {
		return m.Action
	}
	return nil
}

func (m *TaskDefinition) GetDiskMb() int32 {
	if m != nil {
		return m.DiskMb
	}
	return 0
}

func (m *TaskDefinition) GetMemoryMb() int32 {
	if m != nil {
		return m.MemoryMb
	}
	return 0
}

func (m *TaskDefinition) GetCpuWeight() uint32 {
	if m != nil {
		return m.CpuWeight
	}
	return 0
}

func (m *TaskDefinition) GetPrivileged() bool {
	if m != nil {
		return m.Privileged
	}
	return false
}

func (m *TaskDefinition) GetLogSource() string {
	if m != nil {
		return m.LogSource
	}
	return ""
}

func (m *TaskDefinition) GetLogGuid() string {
	if m != nil {
		return m.LogGuid
	}
	return ""
}

func (m *TaskDefinition) GetMetricsGuid() string {
	if m != nil {
		return m.MetricsGuid
	}
	return ""
}

func (m *TaskDefinition) GetResultFile() string {
	if m != nil {
		return m.ResultFile
	}
	return ""
}

func (m *TaskDefinition) GetCompletionCallbackUrl() string {
	if m != nil {
		return m.CompletionCallbackUrl
	}
	return ""
}

func (m *TaskDefinition) GetAnnotation() string {
	if m != nil {
		return m.Annotation
	}
	return ""
}

func (m *TaskDefinition) GetEgressRules() []*SecurityGroupRule {
	if m != nil {
		return m.EgressRules
	}
	return nil
}

func (m *TaskDefinition) GetCachedDependencies() []*CachedDependency {
	if m != nil {
		return m.CachedDependencies
	}
	return nil
}

// Deprecated: Do not use.
func (m *TaskDefinition) GetLegacyDownloadUser() string {
	if m != nil {
		return m.LegacyDownloadUser
	}
	return ""
}

func (m *TaskDefinition) GetTrustedSystemCertificatesPath() string {
	if m != nil {
		return m.TrustedSystemCertificatesPath
	}
	return ""
}

func (m *TaskDefinition) GetVolumeMounts() []*VolumeMount {
	if m != nil {
		return m.VolumeMounts
	}
	return nil
}

func (m *TaskDefinition) GetNetwork() *Network {
	if m != nil {
		return m.Network
	}
	return nil
}

func (m *TaskDefinition) GetPlacementTags() []string {
	if m != nil {
		return m.PlacementTags
	}
	return nil
}

func (m *TaskDefinition) GetMaxPids() int32 {
	if m != nil {
		return m.MaxPids
	}
	return 0
}

func (m *TaskDefinition) GetCertificateProperties() *CertificateProperties {
	if m != nil {
		return m.CertificateProperties
	}
	return nil
}

func (m *TaskDefinition) GetImageUsername() string {
	if m != nil {
		return m.ImageUsername
	}
	return ""
}

func (m *TaskDefinition) GetImagePassword() string {
	if m != nil {
		return m.ImagePassword
	}
	return ""
}

func (m *TaskDefinition) GetImageLayers() []*ImageLayer {
	if m != nil {
		return m.ImageLayers
	}
	return nil
}

func (m *TaskDefinition) GetLogRateLimit() *LogRateLimit {
	if m != nil {
		return m.LogRateLimit
	}
	return nil
}

func (m *TaskDefinition) GetMetricTags() map[string]*MetricTagValue {
	if m != nil {
		return m.MetricTags
	}
	return nil
}

type Task struct {
	*TaskDefinition  `protobuf:"bytes,1,opt,name=task_definition,json=taskDefinition,proto3,embedded=task_definition" json:""`
	TaskGuid         string     `protobuf:"bytes,2,opt,name=task_guid,json=taskGuid,proto3" json:"task_guid"`
	Domain           string     `protobuf:"bytes,3,opt,name=domain,proto3" json:"domain"`
	CreatedAt        int64      `protobuf:"varint,4,opt,name=created_at,json=createdAt,proto3" json:"created_at"`
	UpdatedAt        int64      `protobuf:"varint,5,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at"`
	FirstCompletedAt int64      `protobuf:"varint,6,opt,name=first_completed_at,json=firstCompletedAt,proto3" json:"first_completed_at"`
	State            Task_State `protobuf:"varint,7,opt,name=state,proto3,enum=models.Task_State" json:"state"`
	CellId           string     `protobuf:"bytes,8,opt,name=cell_id,json=cellId,proto3" json:"cell_id"`
	Result           string     `protobuf:"bytes,9,opt,name=result,proto3" json:"result"`
	Failed           bool       `protobuf:"varint,10,opt,name=failed,proto3" json:"failed"`
	FailureReason    string     `protobuf:"bytes,11,opt,name=failure_reason,json=failureReason,proto3" json:"failure_reason"`
	RejectionCount   int32      `protobuf:"varint,12,opt,name=rejection_count,json=rejectionCount,proto3" json:"rejection_count"`
	RejectionReason  string     `protobuf:"bytes,13,opt,name=rejection_reason,json=rejectionReason,proto3" json:"rejection_reason"`
}

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

var xxx_messageInfo_Task proto.InternalMessageInfo

func (m *Task) GetTaskGuid() string {
	if m != nil {
		return m.TaskGuid
	}
	return ""
}

func (m *Task) GetDomain() string {
	if m != nil {
		return m.Domain
	}
	return ""
}

func (m *Task) GetCreatedAt() int64 {
	if m != nil {
		return m.CreatedAt
	}
	return 0
}

func (m *Task) GetUpdatedAt() int64 {
	if m != nil {
		return m.UpdatedAt
	}
	return 0
}

func (m *Task) GetFirstCompletedAt() int64 {
	if m != nil {
		return m.FirstCompletedAt
	}
	return 0
}

func (m *Task) GetState() Task_State {
	if m != nil {
		return m.State
	}
	return Task_Invalid
}

func (m *Task) GetCellId() string {
	if m != nil {
		return m.CellId
	}
	return ""
}

func (m *Task) GetResult() string {
	if m != nil {
		return m.Result
	}
	return ""
}

func (m *Task) GetFailed() bool {
	if m != nil {
		return m.Failed
	}
	return false
}

func (m *Task) GetFailureReason() string {
	if m != nil {
		return m.FailureReason
	}
	return ""
}

func (m *Task) GetRejectionCount() int32 {
	if m != nil {
		return m.RejectionCount
	}
	return 0
}

func (m *Task) GetRejectionReason() string {
	if m != nil {
		return m.RejectionReason
	}
	return ""
}

func init() {
	proto.RegisterEnum("models.Task_State", Task_State_name, Task_State_value)
	proto.RegisterType((*TaskDefinition)(nil), "models.TaskDefinition")
	proto.RegisterMapType((map[string]*MetricTagValue)(nil), "models.TaskDefinition.MetricTagsEntry")
	proto.RegisterType((*Task)(nil), "models.Task")
}

func init() { proto.RegisterFile("task.proto", fileDescriptor_ce5d8dd45b4a91ff) }

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

func (x Task_State) String() string {
	s, ok := Task_State_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *TaskDefinition) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*TaskDefinition)
	if !ok {
		that2, ok := that.(TaskDefinition)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.RootFs != that1.RootFs {
		return false
	}
	if len(this.EnvironmentVariables) != len(that1.EnvironmentVariables) {
		return false
	}
	for i := range this.EnvironmentVariables {
		if !this.EnvironmentVariables[i].Equal(that1.EnvironmentVariables[i]) {
			return false
		}
	}
	if !this.Action.Equal(that1.Action) {
		return false
	}
	if this.DiskMb != that1.DiskMb {
		return false
	}
	if this.MemoryMb != that1.MemoryMb {
		return false
	}
	if this.CpuWeight != that1.CpuWeight {
		return false
	}
	if this.Privileged != that1.Privileged {
		return false
	}
	if this.LogSource != that1.LogSource {
		return false
	}
	if this.LogGuid != that1.LogGuid {
		return false
	}
	if this.MetricsGuid != that1.MetricsGuid {
		return false
	}
	if this.ResultFile != that1.ResultFile {
		return false
	}
	if this.CompletionCallbackUrl != that1.CompletionCallbackUrl {
		return false
	}
	if this.Annotation != that1.Annotation {
		return false
	}
	if len(this.EgressRules) != len(that1.EgressRules) {
		return false
	}
	for i := range this.EgressRules {
		if !this.EgressRules[i].Equal(that1.EgressRules[i]) {
			return false
		}
	}
	if len(this.CachedDependencies) != len(that1.CachedDependencies) {
		return false
	}
	for i := range this.CachedDependencies {
		if !this.CachedDependencies[i].Equal(that1.CachedDependencies[i]) {
			return false
		}
	}
	if this.LegacyDownloadUser != that1.LegacyDownloadUser {
		return false
	}
	if this.TrustedSystemCertificatesPath != that1.TrustedSystemCertificatesPath {
		return false
	}
	if len(this.VolumeMounts) != len(that1.VolumeMounts) {
		return false
	}
	for i := range this.VolumeMounts {
		if !this.VolumeMounts[i].Equal(that1.VolumeMounts[i]) {
			return false
		}
	}
	if !this.Network.Equal(that1.Network) {
		return false
	}
	if len(this.PlacementTags) != len(that1.PlacementTags) {
		return false
	}
	for i := range this.PlacementTags {
		if this.PlacementTags[i] != that1.PlacementTags[i] {
			return false
		}
	}
	if this.MaxPids != that1.MaxPids {
		return false
	}
	if !this.CertificateProperties.Equal(that1.CertificateProperties) {
		return false
	}
	if this.ImageUsername != that1.ImageUsername {
		return false
	}
	if this.ImagePassword != that1.ImagePassword {
		return false
	}
	if len(this.ImageLayers) != len(that1.ImageLayers) {
		return false
	}
	for i := range this.ImageLayers {
		if !this.ImageLayers[i].Equal(that1.ImageLayers[i]) {
			return false
		}
	}
	if !this.LogRateLimit.Equal(that1.LogRateLimit) {
		return false
	}
	if len(this.MetricTags) != len(that1.MetricTags) {
		return false
	}
	for i := range this.MetricTags {
		if !this.MetricTags[i].Equal(that1.MetricTags[i]) {
			return false
		}
	}
	return true
}
func (this *Task) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*Task)
	if !ok {
		that2, ok := that.(Task)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.TaskDefinition.Equal(that1.TaskDefinition) {
		return false
	}
	if this.TaskGuid != that1.TaskGuid {
		return false
	}
	if this.Domain != that1.Domain {
		return false
	}
	if this.CreatedAt != that1.CreatedAt {
		return false
	}
	if this.UpdatedAt != that1.UpdatedAt {
		return false
	}
	if this.FirstCompletedAt != that1.FirstCompletedAt {
		return false
	}
	if this.State != that1.State {
		return false
	}
	if this.CellId != that1.CellId {
		return false
	}
	if this.Result != that1.Result {
		return false
	}
	if this.Failed != that1.Failed {
		return false
	}
	if this.FailureReason != that1.FailureReason {
		return false
	}
	if this.RejectionCount != that1.RejectionCount {
		return false
	}
	if this.RejectionReason != that1.RejectionReason {
		return false
	}
	return true
}
func (this *TaskDefinition) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 31)
	s = append(s, "&models.TaskDefinition{")
	s = append(s, "RootFs: "+fmt.Sprintf("%#v", this.RootFs)+",\n")
	if this.EnvironmentVariables != nil {
		s = append(s, "EnvironmentVariables: "+fmt.Sprintf("%#v", this.EnvironmentVariables)+",\n")
	}
	if this.Action != nil {
		s = append(s, "Action: "+fmt.Sprintf("%#v", this.Action)+",\n")
	}
	s = append(s, "DiskMb: "+fmt.Sprintf("%#v", this.DiskMb)+",\n")
	s = append(s, "MemoryMb: "+fmt.Sprintf("%#v", this.MemoryMb)+",\n")
	s = append(s, "CpuWeight: "+fmt.Sprintf("%#v", this.CpuWeight)+",\n")
	s = append(s, "Privileged: "+fmt.Sprintf("%#v", this.Privileged)+",\n")
	s = append(s, "LogSource: "+fmt.Sprintf("%#v", this.LogSource)+",\n")
	s = append(s, "LogGuid: "+fmt.Sprintf("%#v", this.LogGuid)+",\n")
	s = append(s, "MetricsGuid: "+fmt.Sprintf("%#v", this.MetricsGuid)+",\n")
	s = append(s, "ResultFile: "+fmt.Sprintf("%#v", this.ResultFile)+",\n")
	s = append(s, "CompletionCallbackUrl: "+fmt.Sprintf("%#v", this.CompletionCallbackUrl)+",\n")
	s = append(s, "Annotation: "+fmt.Sprintf("%#v", this.Annotation)+",\n")
	if this.EgressRules != nil {
		s = append(s, "EgressRules: "+fmt.Sprintf("%#v", this.EgressRules)+",\n")
	}
	if this.CachedDependencies != nil {
		s = append(s, "CachedDependencies: "+fmt.Sprintf("%#v", this.CachedDependencies)+",\n")
	}
	s = append(s, "LegacyDownloadUser: "+fmt.Sprintf("%#v", this.LegacyDownloadUser)+",\n")
	s = append(s, "TrustedSystemCertificatesPath: "+fmt.Sprintf("%#v", this.TrustedSystemCertificatesPath)+",\n")
	if this.VolumeMounts != nil {
		s = append(s, "VolumeMounts: "+fmt.Sprintf("%#v", this.VolumeMounts)+",\n")
	}
	if this.Network != nil {
		s = append(s, "Network: "+fmt.Sprintf("%#v", this.Network)+",\n")
	}
	s = append(s, "PlacementTags: "+fmt.Sprintf("%#v", this.PlacementTags)+",\n")
	s = append(s, "MaxPids: "+fmt.Sprintf("%#v", this.MaxPids)+",\n")
	if this.CertificateProperties != nil {
		s = append(s, "CertificateProperties: "+fmt.Sprintf("%#v", this.CertificateProperties)+",\n")
	}
	s = append(s, "ImageUsername: "+fmt.Sprintf("%#v", this.ImageUsername)+",\n")
	s = append(s, "ImagePassword: "+fmt.Sprintf("%#v", this.ImagePassword)+",\n")
	if this.ImageLayers != nil {
		s = append(s, "ImageLayers: "+fmt.Sprintf("%#v", this.ImageLayers)+",\n")
	}
	if this.LogRateLimit != nil {
		s = append(s, "LogRateLimit: "+fmt.Sprintf("%#v", this.LogRateLimit)+",\n")
	}
	keysForMetricTags := make([]string, 0, len(this.MetricTags))
	for k, _ := range this.MetricTags {
		keysForMetricTags = append(keysForMetricTags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetricTags)
	mapStringForMetricTags := "map[string]*MetricTagValue{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%#v: %#v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	if this.MetricTags != nil {
		s = append(s, "MetricTags: "+mapStringForMetricTags+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Task) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 17)
	s = append(s, "&models.Task{")
	if this.TaskDefinition != nil {
		s = append(s, "TaskDefinition: "+fmt.Sprintf("%#v", this.TaskDefinition)+",\n")
	}
	s = append(s, "TaskGuid: "+fmt.Sprintf("%#v", this.TaskGuid)+",\n")
	s = append(s, "Domain: "+fmt.Sprintf("%#v", this.Domain)+",\n")
	s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	s = append(s, "UpdatedAt: "+fmt.Sprintf("%#v", this.UpdatedAt)+",\n")
	s = append(s, "FirstCompletedAt: "+fmt.Sprintf("%#v", this.FirstCompletedAt)+",\n")
	s = append(s, "State: "+fmt.Sprintf("%#v", this.State)+",\n")
	s = append(s, "CellId: "+fmt.Sprintf("%#v", this.CellId)+",\n")
	s = append(s, "Result: "+fmt.Sprintf("%#v", this.Result)+",\n")
	s = append(s, "Failed: "+fmt.Sprintf("%#v", this.Failed)+",\n")
	s = append(s, "FailureReason: "+fmt.Sprintf("%#v", this.FailureReason)+",\n")
	s = append(s, "RejectionCount: "+fmt.Sprintf("%#v", this.RejectionCount)+",\n")
	s = append(s, "RejectionReason: "+fmt.Sprintf("%#v", this.RejectionReason)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringTask(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func (m *TaskDefinition) 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 *TaskDefinition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TaskDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.MetricTags) > 0 {
		for k := range m.MetricTags {
			v := m.MetricTags[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintTask(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTask(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTask(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xda
		}
	}
	if m.LogRateLimit != nil {
		{
			size, err := m.LogRateLimit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xd2
	}
	if len(m.ImageLayers) > 0 {
		for iNdEx := len(m.ImageLayers) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ImageLayers[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTask(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xca
		}
	}
	if len(m.ImagePassword) > 0 {
		i -= len(m.ImagePassword)
		copy(dAtA[i:], m.ImagePassword)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ImagePassword)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xc2
	}
	if len(m.ImageUsername) > 0 {
		i -= len(m.ImageUsername)
		copy(dAtA[i:], m.ImageUsername)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ImageUsername)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xba
	}
	if m.CertificateProperties != nil {
		{
			size, err := m.CertificateProperties.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xb2
	}
	if m.MaxPids != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.MaxPids))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0xa8
	}
	if len(m.PlacementTags) > 0 {
		for iNdEx := len(m.PlacementTags) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PlacementTags[iNdEx])
			copy(dAtA[i:], m.PlacementTags[iNdEx])
			i = encodeVarintTask(dAtA, i, uint64(len(m.PlacementTags[iNdEx])))
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0xa2
		}
	}
	if m.Network != nil {
		{
			size, err := m.Network.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x9a
	}
	if len(m.VolumeMounts) > 0 {
		for iNdEx := len(m.VolumeMounts) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.VolumeMounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTask(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1
			i--
			dAtA[i] = 0x92
		}
	}
	if len(m.TrustedSystemCertificatesPath) > 0 {
		i -= len(m.TrustedSystemCertificatesPath)
		copy(dAtA[i:], m.TrustedSystemCertificatesPath)
		i = encodeVarintTask(dAtA, i, uint64(len(m.TrustedSystemCertificatesPath)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x8a
	}
	if len(m.LegacyDownloadUser) > 0 {
		i -= len(m.LegacyDownloadUser)
		copy(dAtA[i:], m.LegacyDownloadUser)
		i = encodeVarintTask(dAtA, i, uint64(len(m.LegacyDownloadUser)))
		i--
		dAtA[i] = 0x1
		i--
		dAtA[i] = 0x82
	}
	if len(m.CachedDependencies) > 0 {
		for iNdEx := len(m.CachedDependencies) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.CachedDependencies[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTask(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x7a
		}
	}
	if len(m.EgressRules) > 0 {
		for iNdEx := len(m.EgressRules) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EgressRules[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTask(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x72
		}
	}
	if len(m.Annotation) > 0 {
		i -= len(m.Annotation)
		copy(dAtA[i:], m.Annotation)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Annotation)))
		i--
		dAtA[i] = 0x6a
	}
	if len(m.CompletionCallbackUrl) > 0 {
		i -= len(m.CompletionCallbackUrl)
		copy(dAtA[i:], m.CompletionCallbackUrl)
		i = encodeVarintTask(dAtA, i, uint64(len(m.CompletionCallbackUrl)))
		i--
		dAtA[i] = 0x62
	}
	if len(m.ResultFile) > 0 {
		i -= len(m.ResultFile)
		copy(dAtA[i:], m.ResultFile)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ResultFile)))
		i--
		dAtA[i] = 0x5a
	}
	if len(m.MetricsGuid) > 0 {
		i -= len(m.MetricsGuid)
		copy(dAtA[i:], m.MetricsGuid)
		i = encodeVarintTask(dAtA, i, uint64(len(m.MetricsGuid)))
		i--
		dAtA[i] = 0x52
	}
	if len(m.LogGuid) > 0 {
		i -= len(m.LogGuid)
		copy(dAtA[i:], m.LogGuid)
		i = encodeVarintTask(dAtA, i, uint64(len(m.LogGuid)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.LogSource) > 0 {
		i -= len(m.LogSource)
		copy(dAtA[i:], m.LogSource)
		i = encodeVarintTask(dAtA, i, uint64(len(m.LogSource)))
		i--
		dAtA[i] = 0x42
	}
	if m.Privileged {
		i--
		if m.Privileged {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.CpuWeight != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CpuWeight))
		i--
		dAtA[i] = 0x30
	}
	if m.MemoryMb != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.MemoryMb))
		i--
		dAtA[i] = 0x28
	}
	if m.DiskMb != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.DiskMb))
		i--
		dAtA[i] = 0x20
	}
	if m.Action != nil {
		{
			size, err := m.Action.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.EnvironmentVariables) > 0 {
		for iNdEx := len(m.EnvironmentVariables) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.EnvironmentVariables[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintTask(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.RootFs) > 0 {
		i -= len(m.RootFs)
		copy(dAtA[i:], m.RootFs)
		i = encodeVarintTask(dAtA, i, uint64(len(m.RootFs)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Task) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.RejectionReason) > 0 {
		i -= len(m.RejectionReason)
		copy(dAtA[i:], m.RejectionReason)
		i = encodeVarintTask(dAtA, i, uint64(len(m.RejectionReason)))
		i--
		dAtA[i] = 0x6a
	}
	if m.RejectionCount != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.RejectionCount))
		i--
		dAtA[i] = 0x60
	}
	if len(m.FailureReason) > 0 {
		i -= len(m.FailureReason)
		copy(dAtA[i:], m.FailureReason)
		i = encodeVarintTask(dAtA, i, uint64(len(m.FailureReason)))
		i--
		dAtA[i] = 0x5a
	}
	if m.Failed {
		i--
		if m.Failed {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x50
	}
	if len(m.Result) > 0 {
		i -= len(m.Result)
		copy(dAtA[i:], m.Result)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Result)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.CellId) > 0 {
		i -= len(m.CellId)
		copy(dAtA[i:], m.CellId)
		i = encodeVarintTask(dAtA, i, uint64(len(m.CellId)))
		i--
		dAtA[i] = 0x42
	}
	if m.State != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x38
	}
	if m.FirstCompletedAt != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.FirstCompletedAt))
		i--
		dAtA[i] = 0x30
	}
	if m.UpdatedAt != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.UpdatedAt))
		i--
		dAtA[i] = 0x28
	}
	if m.CreatedAt != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CreatedAt))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Domain) > 0 {
		i -= len(m.Domain)
		copy(dAtA[i:], m.Domain)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Domain)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.TaskGuid) > 0 {
		i -= len(m.TaskGuid)
		copy(dAtA[i:], m.TaskGuid)
		i = encodeVarintTask(dAtA, i, uint64(len(m.TaskGuid)))
		i--
		dAtA[i] = 0x12
	}
	if m.TaskDefinition != nil {
		{
			size, err := m.TaskDefinition.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintTask(dAtA []byte, offset int, v uint64) int {
	offset -= sovTask(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TaskDefinition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.RootFs)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if len(m.EnvironmentVariables) > 0 {
		for _, e := range m.EnvironmentVariables {
			l = e.Size()
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if m.Action != nil {
		l = m.Action.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.DiskMb != 0 {
		n += 1 + sovTask(uint64(m.DiskMb))
	}
	if m.MemoryMb != 0 {
		n += 1 + sovTask(uint64(m.MemoryMb))
	}
	if m.CpuWeight != 0 {
		n += 1 + sovTask(uint64(m.CpuWeight))
	}
	if m.Privileged {
		n += 2
	}
	l = len(m.LogSource)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.LogGuid)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.MetricsGuid)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.ResultFile)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.CompletionCallbackUrl)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Annotation)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if len(m.EgressRules) > 0 {
		for _, e := range m.EgressRules {
			l = e.Size()
			n += 1 + l + sovTask(uint64(l))
		}
	}
	if len(m.CachedDependencies) > 0 {
		for _, e := range m.CachedDependencies {
			l = e.Size()
			n += 1 + l + sovTask(uint64(l))
		}
	}
	l = len(m.LegacyDownloadUser)
	if l > 0 {
		n += 2 + l + sovTask(uint64(l))
	}
	l = len(m.TrustedSystemCertificatesPath)
	if l > 0 {
		n += 2 + l + sovTask(uint64(l))
	}
	if len(m.VolumeMounts) > 0 {
		for _, e := range m.VolumeMounts {
			l = e.Size()
			n += 2 + l + sovTask(uint64(l))
		}
	}
	if m.Network != nil {
		l = m.Network.Size()
		n += 2 + l + sovTask(uint64(l))
	}
	if len(m.PlacementTags) > 0 {
		for _, s := range m.PlacementTags {
			l = len(s)
			n += 2 + l + sovTask(uint64(l))
		}
	}
	if m.MaxPids != 0 {
		n += 2 + sovTask(uint64(m.MaxPids))
	}
	if m.CertificateProperties != nil {
		l = m.CertificateProperties.Size()
		n += 2 + l + sovTask(uint64(l))
	}
	l = len(m.ImageUsername)
	if l > 0 {
		n += 2 + l + sovTask(uint64(l))
	}
	l = len(m.ImagePassword)
	if l > 0 {
		n += 2 + l + sovTask(uint64(l))
	}
	if len(m.ImageLayers) > 0 {
		for _, e := range m.ImageLayers {
			l = e.Size()
			n += 2 + l + sovTask(uint64(l))
		}
	}
	if m.LogRateLimit != nil {
		l = m.LogRateLimit.Size()
		n += 2 + l + sovTask(uint64(l))
	}
	if len(m.MetricTags) > 0 {
		for k, v := range m.MetricTags {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTask(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTask(uint64(len(k))) + l
			n += mapEntrySize + 2 + sovTask(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *Task) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TaskDefinition != nil {
		l = m.TaskDefinition.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.TaskGuid)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Domain)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovTask(uint64(m.CreatedAt))
	}
	if m.UpdatedAt != 0 {
		n += 1 + sovTask(uint64(m.UpdatedAt))
	}
	if m.FirstCompletedAt != 0 {
		n += 1 + sovTask(uint64(m.FirstCompletedAt))
	}
	if m.State != 0 {
		n += 1 + sovTask(uint64(m.State))
	}
	l = len(m.CellId)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Result)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Failed {
		n += 2
	}
	l = len(m.FailureReason)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.RejectionCount != 0 {
		n += 1 + sovTask(uint64(m.RejectionCount))
	}
	l = len(m.RejectionReason)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	return n
}

func sovTask(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTask(x uint64) (n int) {
	return sovTask(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *TaskDefinition) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForEnvironmentVariables := "[]*EnvironmentVariable{"
	for _, f := range this.EnvironmentVariables {
		repeatedStringForEnvironmentVariables += strings.Replace(fmt.Sprintf("%v", f), "EnvironmentVariable", "EnvironmentVariable", 1) + ","
	}
	repeatedStringForEnvironmentVariables += "}"
	repeatedStringForEgressRules := "[]*SecurityGroupRule{"
	for _, f := range this.EgressRules {
		repeatedStringForEgressRules += strings.Replace(fmt.Sprintf("%v", f), "SecurityGroupRule", "SecurityGroupRule", 1) + ","
	}
	repeatedStringForEgressRules += "}"
	repeatedStringForCachedDependencies := "[]*CachedDependency{"
	for _, f := range this.CachedDependencies {
		repeatedStringForCachedDependencies += strings.Replace(fmt.Sprintf("%v", f), "CachedDependency", "CachedDependency", 1) + ","
	}
	repeatedStringForCachedDependencies += "}"
	repeatedStringForVolumeMounts := "[]*VolumeMount{"
	for _, f := range this.VolumeMounts {
		repeatedStringForVolumeMounts += strings.Replace(fmt.Sprintf("%v", f), "VolumeMount", "VolumeMount", 1) + ","
	}
	repeatedStringForVolumeMounts += "}"
	repeatedStringForImageLayers := "[]*ImageLayer{"
	for _, f := range this.ImageLayers {
		repeatedStringForImageLayers += strings.Replace(fmt.Sprintf("%v", f), "ImageLayer", "ImageLayer", 1) + ","
	}
	repeatedStringForImageLayers += "}"
	keysForMetricTags := make([]string, 0, len(this.MetricTags))
	for k, _ := range this.MetricTags {
		keysForMetricTags = append(keysForMetricTags, k)
	}
	github_com_gogo_protobuf_sortkeys.Strings(keysForMetricTags)
	mapStringForMetricTags := "map[string]*MetricTagValue{"
	for _, k := range keysForMetricTags {
		mapStringForMetricTags += fmt.Sprintf("%v: %v,", k, this.MetricTags[k])
	}
	mapStringForMetricTags += "}"
	s := strings.Join([]string{`&TaskDefinition{`,
		`RootFs:` + fmt.Sprintf("%v", this.RootFs) + `,`,
		`EnvironmentVariables:` + repeatedStringForEnvironmentVariables + `,`,
		`Action:` + strings.Replace(fmt.Sprintf("%v", this.Action), "Action", "Action", 1) + `,`,
		`DiskMb:` + fmt.Sprintf("%v", this.DiskMb) + `,`,
		`MemoryMb:` + fmt.Sprintf("%v", this.MemoryMb) + `,`,
		`CpuWeight:` + fmt.Sprintf("%v", this.CpuWeight) + `,`,
		`Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`,
		`LogSource:` + fmt.Sprintf("%v", this.LogSource) + `,`,
		`LogGuid:` + fmt.Sprintf("%v", this.LogGuid) + `,`,
		`MetricsGuid:` + fmt.Sprintf("%v", this.MetricsGuid) + `,`,
		`ResultFile:` + fmt.Sprintf("%v", this.ResultFile) + `,`,
		`CompletionCallbackUrl:` + fmt.Sprintf("%v", this.CompletionCallbackUrl) + `,`,
		`Annotation:` + fmt.Sprintf("%v", this.Annotation) + `,`,
		`EgressRules:` + repeatedStringForEgressRules + `,`,
		`CachedDependencies:` + repeatedStringForCachedDependencies + `,`,
		`LegacyDownloadUser:` + fmt.Sprintf("%v", this.LegacyDownloadUser) + `,`,
		`TrustedSystemCertificatesPath:` + fmt.Sprintf("%v", this.TrustedSystemCertificatesPath) + `,`,
		`VolumeMounts:` + repeatedStringForVolumeMounts + `,`,
		`Network:` + strings.Replace(fmt.Sprintf("%v", this.Network), "Network", "Network", 1) + `,`,
		`PlacementTags:` + fmt.Sprintf("%v", this.PlacementTags) + `,`,
		`MaxPids:` + fmt.Sprintf("%v", this.MaxPids) + `,`,
		`CertificateProperties:` + strings.Replace(fmt.Sprintf("%v", this.CertificateProperties), "CertificateProperties", "CertificateProperties", 1) + `,`,
		`ImageUsername:` + fmt.Sprintf("%v", this.ImageUsername) + `,`,
		`ImagePassword:` + fmt.Sprintf("%v", this.ImagePassword) + `,`,
		`ImageLayers:` + repeatedStringForImageLayers + `,`,
		`LogRateLimit:` + strings.Replace(fmt.Sprintf("%v", this.LogRateLimit), "LogRateLimit", "LogRateLimit", 1) + `,`,
		`MetricTags:` + mapStringForMetricTags + `,`,
		`}`,
	}, "")
	return s
}
func (this *Task) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Task{`,
		`TaskDefinition:` + strings.Replace(this.TaskDefinition.String(), "TaskDefinition", "TaskDefinition", 1) + `,`,
		`TaskGuid:` + fmt.Sprintf("%v", this.TaskGuid) + `,`,
		`Domain:` + fmt.Sprintf("%v", this.Domain) + `,`,
		`CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`,
		`UpdatedAt:` + fmt.Sprintf("%v", this.UpdatedAt) + `,`,
		`FirstCompletedAt:` + fmt.Sprintf("%v", this.FirstCompletedAt) + `,`,
		`State:` + fmt.Sprintf("%v", this.State) + `,`,
		`CellId:` + fmt.Sprintf("%v", this.CellId) + `,`,
		`Result:` + fmt.Sprintf("%v", this.Result) + `,`,
		`Failed:` + fmt.Sprintf("%v", this.Failed) + `,`,
		`FailureReason:` + fmt.Sprintf("%v", this.FailureReason) + `,`,
		`RejectionCount:` + fmt.Sprintf("%v", this.RejectionCount) + `,`,
		`RejectionReason:` + fmt.Sprintf("%v", this.RejectionReason) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringTask(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *TaskDefinition) 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 ErrIntOverflowTask
			}
			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: TaskDefinition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaskDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RootFs", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RootFs = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EnvironmentVariables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EnvironmentVariables = append(m.EnvironmentVariables, &EnvironmentVariable{})
			if err := m.EnvironmentVariables[len(m.EnvironmentVariables)-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 Action", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Action == nil {
				m.Action = &Action{}
			}
			if err := m.Action.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DiskMb", wireType)
			}
			m.DiskMb = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DiskMb |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MemoryMb", wireType)
			}
			m.MemoryMb = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MemoryMb |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpuWeight", wireType)
			}
			m.CpuWeight = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CpuWeight |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Privileged", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Privileged = bool(v != 0)
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogSource", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LogSource = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogGuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LogGuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricsGuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MetricsGuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultFile", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ResultFile = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletionCallbackUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CompletionCallbackUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Annotation", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Annotation = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EgressRules", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.EgressRules = append(m.EgressRules, &SecurityGroupRule{})
			if err := m.EgressRules[len(m.EgressRules)-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 CachedDependencies", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CachedDependencies = append(m.CachedDependencies, &CachedDependency{})
			if err := m.CachedDependencies[len(m.CachedDependencies)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LegacyDownloadUser", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LegacyDownloadUser = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 17:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TrustedSystemCertificatesPath", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TrustedSystemCertificatesPath = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 18:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VolumeMounts", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.VolumeMounts = append(m.VolumeMounts, &VolumeMount{})
			if err := m.VolumeMounts[len(m.VolumeMounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 19:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Network == nil {
				m.Network = &Network{}
			}
			if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 20:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PlacementTags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PlacementTags = append(m.PlacementTags, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 21:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxPids", wireType)
			}
			m.MaxPids = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxPids |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 22:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CertificateProperties", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CertificateProperties == nil {
				m.CertificateProperties = &CertificateProperties{}
			}
			if err := m.CertificateProperties.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 23:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageUsername", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageUsername = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 24:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImagePassword", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImagePassword = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 25:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageLayers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageLayers = append(m.ImageLayers, &ImageLayer{})
			if err := m.ImageLayers[len(m.ImageLayers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 26:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogRateLimit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LogRateLimit == nil {
				m.LogRateLimit = &LogRateLimit{}
			}
			if err := m.LogRateLimit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 27:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MetricTags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MetricTags == nil {
				m.MetricTags = make(map[string]*MetricTagValue)
			}
			var mapkey string
			var mapvalue *MetricTagValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowTask
					}
					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 ErrIntOverflowTask
						}
						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 ErrInvalidLengthTask
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTask
					}
					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 ErrIntOverflowTask
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTask
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTask
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &MetricTagValue{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipTask(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTask
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MetricTags[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Task) 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 ErrIntOverflowTask
			}
			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: Task: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Task: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskDefinition", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TaskDefinition == nil {
				m.TaskDefinition = &TaskDefinition{}
			}
			if err := m.TaskDefinition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskGuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TaskGuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Domain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Domain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdatedAt", wireType)
			}
			m.UpdatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FirstCompletedAt", wireType)
			}
			m.FirstCompletedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FirstCompletedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= Task_State(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CellId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CellId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Result = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failed", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Failed = bool(v != 0)
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FailureReason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FailureReason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 12:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RejectionCount", wireType)
			}
			m.RejectionCount = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RejectionCount |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RejectionReason", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				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 ErrInvalidLengthTask
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RejectionReason = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTask(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTask
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthTask        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTask          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTask = fmt.Errorf("proto: unexpected end of group")
)
