github.com/matrixorigin/matrixone@v1.2.0/pkg/pb/task/task.pb.go

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

package task

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

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
	_ "github.com/matrixorigin/matrixone/pkg/pb/metadata"
	_ "google.golang.org/protobuf/types/known/timestamppb"
)

// 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

// TaskStatus task status
type TaskStatus int32

const (
	// Create is the state of waiting to be scheduled.
	TaskStatus_Created TaskStatus = 0
	// Running is running state. Task is assigned to a CN node and is running
	TaskStatus_Running TaskStatus = 1
	// Completed the task has been completed.
	TaskStatus_Completed TaskStatus = 2
	// Paused is the state that the task has been paused by user.
	TaskStatus_Paused TaskStatus = 3
	// Error is the state that the task encounters some kind of error.
	TaskStatus_Error TaskStatus = 4
	// Canceled is the state that the task is canceled by user.
	TaskStatus_Canceled TaskStatus = 5
	// ResumeRequested is the state that resume request has been proposed to
	// the task and has not been resume.
	TaskStatus_ResumeRequested TaskStatus = 6
	// PauseRequested is the state that pause request has been proposed to
	// the task and has not been paused.
	TaskStatus_PauseRequested TaskStatus = 7
	// CancelRequested is the state that cancel request has been proposed to
	// the task and has not been canceled.
	TaskStatus_CancelRequested TaskStatus = 8
)

var TaskStatus_name = map[int32]string{
	0: "Created",
	1: "Running",
	2: "Completed",
	3: "Paused",
	4: "Error",
	5: "Canceled",
	6: "ResumeRequested",
	7: "PauseRequested",
	8: "CancelRequested",
}

var TaskStatus_value = map[string]int32{
	"Created":         0,
	"Running":         1,
	"Completed":       2,
	"Paused":          3,
	"Error":           4,
	"Canceled":        5,
	"ResumeRequested": 6,
	"PauseRequested":  7,
	"CancelRequested": 8,
}

func (x TaskStatus) String() string {
	return proto.EnumName(TaskStatus_name, int32(x))
}

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

// TaskCode task code
type TaskCode int32

const (
	// TestOnly reserved for testing.
	TaskCode_TestOnly TaskCode = 0
	// SystemInit system init task
	TaskCode_SystemInit TaskCode = 1
	// MetricLogMerge handle metric/log exported data merge task
	TaskCode_MetricLogMerge TaskCode = 2
	// MetricStorageUsage handle metric server_storage_usage collection
	TaskCode_MetricStorageUsage TaskCode = 3
	// ConnectorKafkaSink is for the streaming connector task.
	TaskCode_ConnectorKafkaSink TaskCode = 4
	// MergeObject is for the merge object task.
	TaskCode_MergeObject TaskCode = 5
)

var TaskCode_name = map[int32]string{
	0: "TestOnly",
	1: "SystemInit",
	2: "MetricLogMerge",
	3: "MetricStorageUsage",
	4: "ConnectorKafkaSink",
	5: "MergeObject",
}

var TaskCode_value = map[string]int32{
	"TestOnly":           0,
	"SystemInit":         1,
	"MetricLogMerge":     2,
	"MetricStorageUsage": 3,
	"ConnectorKafkaSink": 4,
	"MergeObject":        5,
}

func (x TaskCode) String() string {
	return proto.EnumName(TaskCode_name, int32(x))
}

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

// ResultCode result code
type ResultCode int32

const (
	// Success success
	ResultCode_Success ResultCode = 0
	// Failed failed
	ResultCode_Failed ResultCode = 1
)

var ResultCode_name = map[int32]string{
	0: "Success",
	1: "Failed",
}

var ResultCode_value = map[string]int32{
	"Success": 0,
	"Failed":  1,
}

func (x ResultCode) String() string {
	return proto.EnumName(ResultCode_name, int32(x))
}

func (ResultCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ce5d8dd45b4a91ff, []int{2}
}

type TaskType int32

const (
	TaskType_TypeUnknown            TaskType = 0
	TaskType_TypeKafkaSinkConnector TaskType = 1
)

var TaskType_name = map[int32]string{
	0: "Unknown",
	1: "KafkaSinkConnector",
}

var TaskType_value = map[string]int32{
	"Unknown":            0,
	"KafkaSinkConnector": 1,
}

func (x TaskType) String() string {
	return proto.EnumName(TaskType_name, int32(x))
}

func (TaskType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_ce5d8dd45b4a91ff, []int{3}
}

// TaskMetadata is a task metadata abstraction that can be scheduled for execution at any CN node.
type TaskMetadata struct {
	// ID task id, global unique
	ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
	// Executor used to select a particular task executor to run a task
	Executor TaskCode `protobuf:"varint,2,opt,name=Executor,proto3,enum=task.TaskCode" json:"Executor,omitempty"`
	// Context context needed to run the task
	Context []byte `protobuf:"bytes,3,opt,name=Context,proto3" json:"Context,omitempty"`
	// Options options for execute task
	Options              TaskOptions `protobuf:"bytes,4,opt,name=Options,proto3" json:"Options"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_TaskMetadata proto.InternalMessageInfo

func (m *TaskMetadata) GetID() string {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *TaskMetadata) GetExecutor() TaskCode {
	if m != nil {
		return m.Executor
	}
	return TaskCode_TestOnly
}

func (m *TaskMetadata) GetContext() []byte {
	if m != nil {
		return m.Context
	}
	return nil
}

func (m *TaskMetadata) GetOptions() TaskOptions {
	if m != nil {
		return m.Options
	}
	return TaskOptions{}
}

// TaskOptions task options
type TaskOptions struct {
	// MaxRetryTimes 0 means disable retry
	MaxRetryTimes uint32 `protobuf:"varint,1,opt,name=MaxRetryTimes,proto3" json:"MaxRetryTimes,omitempty"`
	// RetryInterval retry interval
	RetryInterval int64 `protobuf:"varint,2,opt,name=RetryInterval,proto3" json:"RetryInterval,omitempty"`
	// DelayDuration delay duration. Controls how long a task is delayed before it is scheduled for
	// execution.
	DelayDuration int64 `protobuf:"varint,3,opt,name=DelayDuration,proto3" json:"DelayDuration,omitempty"`
	// Concurrency is the max number of a task running at the same time. 0 means no limits.
	Concurrency uint32 `protobuf:"varint,4,opt,name=Concurrency,proto3" json:"Concurrency,omitempty"`
	// Labels indicates that the task should run on the CNs with the Labels.
	Labels map[string]string `protobuf:"bytes,5,rep,name=Labels,proto3" json:"Labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// Resource required by the task
	Resource             *Resource `protobuf:"bytes,6,opt,name=Resource,proto3" json:"Resource,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_TaskOptions proto.InternalMessageInfo

func (m *TaskOptions) GetMaxRetryTimes() uint32 {
	if m != nil {
		return m.MaxRetryTimes
	}
	return 0
}

func (m *TaskOptions) GetRetryInterval() int64 {
	if m != nil {
		return m.RetryInterval
	}
	return 0
}

func (m *TaskOptions) GetDelayDuration() int64 {
	if m != nil {
		return m.DelayDuration
	}
	return 0
}

func (m *TaskOptions) GetConcurrency() uint32 {
	if m != nil {
		return m.Concurrency
	}
	return 0
}

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

func (m *TaskOptions) GetResource() *Resource {
	if m != nil {
		return m.Resource
	}
	return nil
}

// Resource task resource
type Resource struct {
	// CPU cpu resource
	CPU uint64 `protobuf:"varint,1,opt,name=CPU,proto3" json:"CPU,omitempty"`
	// Memory memory resource
	Memory               uint64   `protobuf:"varint,2,opt,name=Memory,proto3" json:"Memory,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Resource proto.InternalMessageInfo

func (m *Resource) GetCPU() uint64 {
	if m != nil {
		return m.CPU
	}
	return 0
}

func (m *Resource) GetMemory() uint64 {
	if m != nil {
		return m.Memory
	}
	return 0
}

// ExecuteResult task execute result
type ExecuteResult struct {
	// Code result code
	Code ResultCode `protobuf:"varint,1,opt,name=Code,proto3,enum=task.ResultCode" json:"Code,omitempty"`
	// Error error message
	Error                string   `protobuf:"bytes,2,opt,name=Error,proto3" json:"Error,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ExecuteResult proto.InternalMessageInfo

func (m *ExecuteResult) GetCode() ResultCode {
	if m != nil {
		return m.Code
	}
	return ResultCode_Success
}

func (m *ExecuteResult) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

// Task task execute info.
type AsyncTask struct {
	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
	// TaskMetadata task metadata
	Metadata TaskMetadata `protobuf:"bytes,2,opt,name=Metadata,proto3" json:"Metadata"`
	// ParentTaskID used to record the parent task of the current task
	ParentTaskID string `protobuf:"bytes,3,opt,name=ParentTaskID,proto3" json:"ParentTaskID,omitempty"`
	// TaskStatus task status
	Status TaskStatus `protobuf:"varint,4,opt,name=Status,proto3,enum=task.TaskStatus" json:"Status,omitempty"`
	// TaskRunner is the UUID of the CN node which the task run is assigned to
	TaskRunner string `protobuf:"bytes,5,opt,name=TaskRunner,proto3" json:"TaskRunner,omitempty"`
	// Epoch indicates how many times the current task is scheduled, the first time it is scheduled
	// is 1. Each time it is scheduled, Epoch++.
	Epoch uint32 `protobuf:"varint,6,opt,name=Epoch,proto3" json:"Epoch,omitempty"`
	// LastHeartbeat time of the last heartbeat reported by TaskRunner. Unix timestamp in ms
	LastHeartbeat int64 `protobuf:"varint,7,opt,name=LastHeartbeat,proto3" json:"LastHeartbeat,omitempty"`
	// CreateAt time of the task created. Unix timestamp in ms
	CreateAt int64 `protobuf:"varint,8,opt,name=CreateAt,proto3" json:"CreateAt,omitempty"`
	// CompletedAt time of the task completed. Unix timestamp in ms
	CompletedAt int64 `protobuf:"varint,9,opt,name=CompletedAt,proto3" json:"CompletedAt,omitempty"`
	// ExecuteResult execute result
	ExecuteResult        *ExecuteResult `protobuf:"bytes,10,opt,name=ExecuteResult,proto3" json:"ExecuteResult,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_AsyncTask proto.InternalMessageInfo

func (m *AsyncTask) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *AsyncTask) GetMetadata() TaskMetadata {
	if m != nil {
		return m.Metadata
	}
	return TaskMetadata{}
}

func (m *AsyncTask) GetParentTaskID() string {
	if m != nil {
		return m.ParentTaskID
	}
	return ""
}

func (m *AsyncTask) GetStatus() TaskStatus {
	if m != nil {
		return m.Status
	}
	return TaskStatus_Created
}

func (m *AsyncTask) GetTaskRunner() string {
	if m != nil {
		return m.TaskRunner
	}
	return ""
}

func (m *AsyncTask) GetEpoch() uint32 {
	if m != nil {
		return m.Epoch
	}
	return 0
}

func (m *AsyncTask) GetLastHeartbeat() int64 {
	if m != nil {
		return m.LastHeartbeat
	}
	return 0
}

func (m *AsyncTask) GetCreateAt() int64 {
	if m != nil {
		return m.CreateAt
	}
	return 0
}

func (m *AsyncTask) GetCompletedAt() int64 {
	if m != nil {
		return m.CompletedAt
	}
	return 0
}

func (m *AsyncTask) GetExecuteResult() *ExecuteResult {
	if m != nil {
		return m.ExecuteResult
	}
	return nil
}

// CronTask task execute info.
type CronTask struct {
	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
	// TaskMetadata task metadata
	Metadata TaskMetadata `protobuf:"bytes,2,opt,name=Metadata,proto3" json:"Metadata"`
	// CronExpr cron expr
	CronExpr string `protobuf:"bytes,3,opt,name=CronExpr,proto3" json:"CronExpr,omitempty"`
	// NextTime the next time it should be scheduled for execution. Unix timestamp in ms
	NextTime int64 `protobuf:"varint,4,opt,name=NextTime,proto3" json:"NextTime,omitempty"`
	// TriggerTimes the number of times it was triggered
	TriggerTimes uint64 `protobuf:"varint,5,opt,name=TriggerTimes,proto3" json:"TriggerTimes,omitempty"`
	// CreateAt time of the cron task created. Unix timestamp in ms
	CreateAt int64 `protobuf:"varint,6,opt,name=CreateAt,proto3" json:"CreateAt,omitempty"`
	// CreateAt time of the cron task created. Unix timestamp in ms
	UpdateAt             int64    `protobuf:"varint,7,opt,name=UpdateAt,proto3" json:"UpdateAt,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CronTask proto.InternalMessageInfo

func (m *CronTask) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *CronTask) GetMetadata() TaskMetadata {
	if m != nil {
		return m.Metadata
	}
	return TaskMetadata{}
}

func (m *CronTask) GetCronExpr() string {
	if m != nil {
		return m.CronExpr
	}
	return ""
}

func (m *CronTask) GetNextTime() int64 {
	if m != nil {
		return m.NextTime
	}
	return 0
}

func (m *CronTask) GetTriggerTimes() uint64 {
	if m != nil {
		return m.TriggerTimes
	}
	return 0
}

func (m *CronTask) GetCreateAt() int64 {
	if m != nil {
		return m.CreateAt
	}
	return 0
}

func (m *CronTask) GetUpdateAt() int64 {
	if m != nil {
		return m.UpdateAt
	}
	return 0
}

type ConnectorDetails struct {
	TableName            string            `protobuf:"bytes,1,opt,name=TableName,proto3" json:"TableName,omitempty"`
	Options              map[string]string `protobuf:"bytes,2,rep,name=Options,proto3" json:"Options,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_ConnectorDetails proto.InternalMessageInfo

func (m *ConnectorDetails) GetTableName() string {
	if m != nil {
		return m.TableName
	}
	return ""
}

func (m *ConnectorDetails) GetOptions() map[string]string {
	if m != nil {
		return m.Options
	}
	return nil
}

type Details struct {
	Description string `protobuf:"bytes,1,opt,name=Description,proto3" json:"Description,omitempty"`
	AccountID   uint32 `protobuf:"varint,2,opt,name=AccountID,proto3" json:"AccountID,omitempty"`
	Account     string `protobuf:"bytes,3,opt,name=Account,proto3" json:"Account,omitempty"`
	Username    string `protobuf:"bytes,4,opt,name=Username,proto3" json:"Username,omitempty"`
	Error       string `protobuf:"bytes,5,opt,name=Error,proto3" json:"Error,omitempty"`
	// Types that are valid to be assigned to Details:
	//
	//	*Details_Connector
	Details              isDetails_Details `protobuf_oneof:"Details"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_Details proto.InternalMessageInfo

type isDetails_Details interface {
	isDetails_Details()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Details_Connector struct {
	Connector *ConnectorDetails `protobuf:"bytes,10,opt,name=Connector,proto3,oneof" json:"Connector,omitempty"`
}

func (*Details_Connector) isDetails_Details() {}

func (m *Details) GetDetails() isDetails_Details {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *Details) GetDescription() string {
	if m != nil {
		return m.Description
	}
	return ""
}

func (m *Details) GetAccountID() uint32 {
	if m != nil {
		return m.AccountID
	}
	return 0
}

func (m *Details) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

func (m *Details) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *Details) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

func (m *Details) GetConnector() *ConnectorDetails {
	if x, ok := m.GetDetails().(*Details_Connector); ok {
		return x.Connector
	}
	return nil
}

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Details) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Details_Connector)(nil),
	}
}

type DaemonTask struct {
	ID                   uint64       `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
	Metadata             TaskMetadata `protobuf:"bytes,2,opt,name=Metadata,proto3" json:"Metadata"`
	AccountID            uint32       `protobuf:"varint,3,opt,name=AccountID,proto3" json:"AccountID,omitempty"`
	Account              string       `protobuf:"bytes,4,opt,name=Account,proto3" json:"Account,omitempty"`
	TaskType             TaskType     `protobuf:"varint,5,opt,name=TaskType,proto3,enum=task.TaskType" json:"TaskType,omitempty"`
	TaskRunner           string       `protobuf:"bytes,6,opt,name=TaskRunner,proto3" json:"TaskRunner,omitempty"`
	TaskStatus           TaskStatus   `protobuf:"varint,7,opt,name=TaskStatus,proto3,enum=task.TaskStatus" json:"TaskStatus,omitempty"`
	LastHeartbeat        time.Time    `protobuf:"bytes,8,opt,name=LastHeartbeat,proto3,stdtime" json:"LastHeartbeat"`
	Details              *Details     `protobuf:"bytes,9,opt,name=Details,proto3" json:"Details,omitempty"`
	CreateAt             time.Time    `protobuf:"bytes,10,opt,name=CreateAt,proto3,stdtime" json:"CreateAt"`
	UpdateAt             time.Time    `protobuf:"bytes,11,opt,name=UpdateAt,proto3,stdtime" json:"UpdateAt"`
	EndAt                time.Time    `protobuf:"bytes,12,opt,name=EndAt,proto3,stdtime" json:"EndAt"`
	LastRun              time.Time    `protobuf:"bytes,13,opt,name=LastRun,proto3,stdtime" json:"LastRun"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_DaemonTask proto.InternalMessageInfo

func (m *DaemonTask) GetID() uint64 {
	if m != nil {
		return m.ID
	}
	return 0
}

func (m *DaemonTask) GetMetadata() TaskMetadata {
	if m != nil {
		return m.Metadata
	}
	return TaskMetadata{}
}

func (m *DaemonTask) GetAccountID() uint32 {
	if m != nil {
		return m.AccountID
	}
	return 0
}

func (m *DaemonTask) GetAccount() string {
	if m != nil {
		return m.Account
	}
	return ""
}

func (m *DaemonTask) GetTaskType() TaskType {
	if m != nil {
		return m.TaskType
	}
	return TaskType_TypeUnknown
}

func (m *DaemonTask) GetTaskRunner() string {
	if m != nil {
		return m.TaskRunner
	}
	return ""
}

func (m *DaemonTask) GetTaskStatus() TaskStatus {
	if m != nil {
		return m.TaskStatus
	}
	return TaskStatus_Created
}

func (m *DaemonTask) GetLastHeartbeat() time.Time {
	if m != nil {
		return m.LastHeartbeat
	}
	return time.Time{}
}

func (m *DaemonTask) GetDetails() *Details {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *DaemonTask) GetCreateAt() time.Time {
	if m != nil {
		return m.CreateAt
	}
	return time.Time{}
}

func (m *DaemonTask) GetUpdateAt() time.Time {
	if m != nil {
		return m.UpdateAt
	}
	return time.Time{}
}

func (m *DaemonTask) GetEndAt() time.Time {
	if m != nil {
		return m.EndAt
	}
	return time.Time{}
}

func (m *DaemonTask) GetLastRun() time.Time {
	if m != nil {
		return m.LastRun
	}
	return time.Time{}
}

func init() {
	proto.RegisterEnum("task.TaskStatus", TaskStatus_name, TaskStatus_value)
	proto.RegisterEnum("task.TaskCode", TaskCode_name, TaskCode_value)
	proto.RegisterEnum("task.ResultCode", ResultCode_name, ResultCode_value)
	proto.RegisterEnum("task.TaskType", TaskType_name, TaskType_value)
	proto.RegisterType((*TaskMetadata)(nil), "task.TaskMetadata")
	proto.RegisterType((*TaskOptions)(nil), "task.TaskOptions")
	proto.RegisterMapType((map[string]string)(nil), "task.TaskOptions.LabelsEntry")
	proto.RegisterType((*Resource)(nil), "task.Resource")
	proto.RegisterType((*ExecuteResult)(nil), "task.ExecuteResult")
	proto.RegisterType((*AsyncTask)(nil), "task.AsyncTask")
	proto.RegisterType((*CronTask)(nil), "task.CronTask")
	proto.RegisterType((*ConnectorDetails)(nil), "task.ConnectorDetails")
	proto.RegisterMapType((map[string]string)(nil), "task.ConnectorDetails.OptionsEntry")
	proto.RegisterType((*Details)(nil), "task.Details")
	proto.RegisterType((*DaemonTask)(nil), "task.DaemonTask")
}

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

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

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

func (m *TaskMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	{
		size, err := m.Options.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTask(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	if len(m.Context) > 0 {
		i -= len(m.Context)
		copy(dAtA[i:], m.Context)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Context)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Executor != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Executor))
		i--
		dAtA[i] = 0x10
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TaskOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Resource != nil {
		{
			size, err := m.Resource.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintTask(dAtA, i, uint64(len(v)))
			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] = 0x2a
		}
	}
	if m.Concurrency != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Concurrency))
		i--
		dAtA[i] = 0x20
	}
	if m.DelayDuration != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.DelayDuration))
		i--
		dAtA[i] = 0x18
	}
	if m.RetryInterval != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.RetryInterval))
		i--
		dAtA[i] = 0x10
	}
	if m.MaxRetryTimes != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.MaxRetryTimes))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *Resource) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Memory != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Memory))
		i--
		dAtA[i] = 0x10
	}
	if m.CPU != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CPU))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ExecuteResult) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x12
	}
	if m.Code != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *AsyncTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.ExecuteResult != nil {
		{
			size, err := m.ExecuteResult.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	if m.CompletedAt != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CompletedAt))
		i--
		dAtA[i] = 0x48
	}
	if m.CreateAt != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CreateAt))
		i--
		dAtA[i] = 0x40
	}
	if m.LastHeartbeat != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.LastHeartbeat))
		i--
		dAtA[i] = 0x38
	}
	if m.Epoch != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Epoch))
		i--
		dAtA[i] = 0x30
	}
	if len(m.TaskRunner) > 0 {
		i -= len(m.TaskRunner)
		copy(dAtA[i:], m.TaskRunner)
		i = encodeVarintTask(dAtA, i, uint64(len(m.TaskRunner)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Status != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x20
	}
	if len(m.ParentTaskID) > 0 {
		i -= len(m.ParentTaskID)
		copy(dAtA[i:], m.ParentTaskID)
		i = encodeVarintTask(dAtA, i, uint64(len(m.ParentTaskID)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTask(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ID != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CronTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.UpdateAt != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.UpdateAt))
		i--
		dAtA[i] = 0x38
	}
	if m.CreateAt != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.CreateAt))
		i--
		dAtA[i] = 0x30
	}
	if m.TriggerTimes != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.TriggerTimes))
		i--
		dAtA[i] = 0x28
	}
	if m.NextTime != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.NextTime))
		i--
		dAtA[i] = 0x20
	}
	if len(m.CronExpr) > 0 {
		i -= len(m.CronExpr)
		copy(dAtA[i:], m.CronExpr)
		i = encodeVarintTask(dAtA, i, uint64(len(m.CronExpr)))
		i--
		dAtA[i] = 0x1a
	}
	{
		size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTask(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ID != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ConnectorDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Options) > 0 {
		for k := range m.Options {
			v := m.Options[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintTask(dAtA, i, uint64(len(v)))
			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] = 0x12
		}
	}
	if len(m.TableName) > 0 {
		i -= len(m.TableName)
		copy(dAtA[i:], m.TableName)
		i = encodeVarintTask(dAtA, i, uint64(len(m.TableName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Details) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Details != nil {
		{
			size := m.Details.Size()
			i -= size
			if _, err := m.Details.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Account) > 0 {
		i -= len(m.Account)
		copy(dAtA[i:], m.Account)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Account)))
		i--
		dAtA[i] = 0x1a
	}
	if m.AccountID != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.AccountID))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Description) > 0 {
		i -= len(m.Description)
		copy(dAtA[i:], m.Description)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Description)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Details_Connector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Connector != nil {
		{
			size, err := m.Connector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x52
	}
	return len(dAtA) - i, nil
}
func (m *DaemonTask) 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 *DaemonTask) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DaemonTask) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	n7, err7 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastRun, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastRun):])
	if err7 != nil {
		return 0, err7
	}
	i -= n7
	i = encodeVarintTask(dAtA, i, uint64(n7))
	i--
	dAtA[i] = 0x6a
	n8, err8 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.EndAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.EndAt):])
	if err8 != nil {
		return 0, err8
	}
	i -= n8
	i = encodeVarintTask(dAtA, i, uint64(n8))
	i--
	dAtA[i] = 0x62
	n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.UpdateAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateAt):])
	if err9 != nil {
		return 0, err9
	}
	i -= n9
	i = encodeVarintTask(dAtA, i, uint64(n9))
	i--
	dAtA[i] = 0x5a
	n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.CreateAt, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.CreateAt):])
	if err10 != nil {
		return 0, err10
	}
	i -= n10
	i = encodeVarintTask(dAtA, i, uint64(n10))
	i--
	dAtA[i] = 0x52
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTask(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	n12, err12 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.LastHeartbeat, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.LastHeartbeat):])
	if err12 != nil {
		return 0, err12
	}
	i -= n12
	i = encodeVarintTask(dAtA, i, uint64(n12))
	i--
	dAtA[i] = 0x42
	if m.TaskStatus != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.TaskStatus))
		i--
		dAtA[i] = 0x38
	}
	if len(m.TaskRunner) > 0 {
		i -= len(m.TaskRunner)
		copy(dAtA[i:], m.TaskRunner)
		i = encodeVarintTask(dAtA, i, uint64(len(m.TaskRunner)))
		i--
		dAtA[i] = 0x32
	}
	if m.TaskType != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.TaskType))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Account) > 0 {
		i -= len(m.Account)
		copy(dAtA[i:], m.Account)
		i = encodeVarintTask(dAtA, i, uint64(len(m.Account)))
		i--
		dAtA[i] = 0x22
	}
	if m.AccountID != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.AccountID))
		i--
		dAtA[i] = 0x18
	}
	{
		size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTask(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.ID != 0 {
		i = encodeVarintTask(dAtA, i, uint64(m.ID))
		i--
		dAtA[i] = 0x8
	}
	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 *TaskMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Executor != 0 {
		n += 1 + sovTask(uint64(m.Executor))
	}
	l = len(m.Context)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = m.Options.Size()
	n += 1 + l + sovTask(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TaskOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MaxRetryTimes != 0 {
		n += 1 + sovTask(uint64(m.MaxRetryTimes))
	}
	if m.RetryInterval != 0 {
		n += 1 + sovTask(uint64(m.RetryInterval))
	}
	if m.DelayDuration != 0 {
		n += 1 + sovTask(uint64(m.DelayDuration))
	}
	if m.Concurrency != 0 {
		n += 1 + sovTask(uint64(m.Concurrency))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovTask(uint64(len(k))) + 1 + len(v) + sovTask(uint64(len(v)))
			n += mapEntrySize + 1 + sovTask(uint64(mapEntrySize))
		}
	}
	if m.Resource != nil {
		l = m.Resource.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Resource) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.CPU != 0 {
		n += 1 + sovTask(uint64(m.CPU))
	}
	if m.Memory != 0 {
		n += 1 + sovTask(uint64(m.Memory))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ExecuteResult) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Code != 0 {
		n += 1 + sovTask(uint64(m.Code))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AsyncTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovTask(uint64(m.ID))
	}
	l = m.Metadata.Size()
	n += 1 + l + sovTask(uint64(l))
	l = len(m.ParentTaskID)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovTask(uint64(m.Status))
	}
	l = len(m.TaskRunner)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Epoch != 0 {
		n += 1 + sovTask(uint64(m.Epoch))
	}
	if m.LastHeartbeat != 0 {
		n += 1 + sovTask(uint64(m.LastHeartbeat))
	}
	if m.CreateAt != 0 {
		n += 1 + sovTask(uint64(m.CreateAt))
	}
	if m.CompletedAt != 0 {
		n += 1 + sovTask(uint64(m.CompletedAt))
	}
	if m.ExecuteResult != nil {
		l = m.ExecuteResult.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CronTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovTask(uint64(m.ID))
	}
	l = m.Metadata.Size()
	n += 1 + l + sovTask(uint64(l))
	l = len(m.CronExpr)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.NextTime != 0 {
		n += 1 + sovTask(uint64(m.NextTime))
	}
	if m.TriggerTimes != 0 {
		n += 1 + sovTask(uint64(m.TriggerTimes))
	}
	if m.CreateAt != 0 {
		n += 1 + sovTask(uint64(m.CreateAt))
	}
	if m.UpdateAt != 0 {
		n += 1 + sovTask(uint64(m.UpdateAt))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Details) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Description)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.AccountID != 0 {
		n += 1 + sovTask(uint64(m.AccountID))
	}
	l = len(m.Account)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.Details != nil {
		n += m.Details.Size()
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Details_Connector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Connector != nil {
		l = m.Connector.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	return n
}
func (m *DaemonTask) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != 0 {
		n += 1 + sovTask(uint64(m.ID))
	}
	l = m.Metadata.Size()
	n += 1 + l + sovTask(uint64(l))
	if m.AccountID != 0 {
		n += 1 + sovTask(uint64(m.AccountID))
	}
	l = len(m.Account)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.TaskType != 0 {
		n += 1 + sovTask(uint64(m.TaskType))
	}
	l = len(m.TaskRunner)
	if l > 0 {
		n += 1 + l + sovTask(uint64(l))
	}
	if m.TaskStatus != 0 {
		n += 1 + sovTask(uint64(m.TaskStatus))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LastHeartbeat)
	n += 1 + l + sovTask(uint64(l))
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovTask(uint64(l))
	}
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.CreateAt)
	n += 1 + l + sovTask(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.UpdateAt)
	n += 1 + l + sovTask(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.EndAt)
	n += 1 + l + sovTask(uint64(l))
	l = github_com_gogo_protobuf_types.SizeOfStdTime(m.LastRun)
	n += 1 + l + sovTask(uint64(l))
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	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 (m *TaskMetadata) 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: TaskMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaskMetadata: 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 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.ID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executor", wireType)
			}
			m.Executor = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Executor |= TaskCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Context", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthTask
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthTask
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Context = append(m.Context[:0], dAtA[iNdEx:postIndex]...)
			if m.Context == nil {
				m.Context = []byte{}
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", 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 err := m.Options.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TaskOptions) 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: TaskOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TaskOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxRetryTimes", wireType)
			}
			m.MaxRetryTimes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxRetryTimes |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RetryInterval", wireType)
			}
			m.RetryInterval = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RetryInterval |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field DelayDuration", wireType)
			}
			m.DelayDuration = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.DelayDuration |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Concurrency", wireType)
			}
			m.Concurrency = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Concurrency |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 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.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 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 stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTask
						}
						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 ErrInvalidLengthTask
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthTask
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} 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.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Resource", 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.Resource == nil {
				m.Resource = &Resource{}
			}
			if err := m.Resource.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Resource) 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: Resource: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Resource: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CPU", wireType)
			}
			m.CPU = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CPU |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			m.Memory = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Memory |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ExecuteResult) 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: ExecuteResult: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ExecuteResult: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= ResultCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error = 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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AsyncTask) 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: AsyncTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AsyncTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ParentTaskID", 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.ParentTaskID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= TaskStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskRunner", 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.TaskRunner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Epoch", wireType)
			}
			m.Epoch = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Epoch |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastHeartbeat", wireType)
			}
			m.LastHeartbeat = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastHeartbeat |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateAt", wireType)
			}
			m.CreateAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreateAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 9:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletedAt", wireType)
			}
			m.CompletedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CompletedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecuteResult", 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.ExecuteResult == nil {
				m.ExecuteResult = &ExecuteResult{}
			}
			if err := m.ExecuteResult.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CronTask) 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: CronTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CronTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CronExpr", 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.CronExpr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NextTime", wireType)
			}
			m.NextTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NextTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TriggerTimes", wireType)
			}
			m.TriggerTimes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TriggerTimes |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateAt", wireType)
			}
			m.CreateAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreateAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateAt", wireType)
			}
			m.UpdateAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.UpdateAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConnectorDetails) 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: ConnectorDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConnectorDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TableName", 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.TableName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Options", 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.Options == nil {
				m.Options = 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 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 stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowTask
						}
						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 ErrInvalidLengthTask
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthTask
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} 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.Options[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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Details) 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: Details: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Details: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Description", 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.Description = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountID", wireType)
			}
			m.AccountID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AccountID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", 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.Account = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", 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.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", 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.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Connector", 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
			}
			v := &ConnectorDetails{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Details = &Details_Connector{v}
			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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DaemonTask) 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: DaemonTask: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DaemonTask: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			m.ID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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 err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field AccountID", wireType)
			}
			m.AccountID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.AccountID |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Account", 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.Account = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskType", wireType)
			}
			m.TaskType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskType |= TaskType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskRunner", 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.TaskRunner = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TaskStatus", wireType)
			}
			m.TaskStatus = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTask
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TaskStatus |= TaskStatus(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastHeartbeat", 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LastHeartbeat, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", 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.Details == nil {
				m.Details = &Details{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreateAt", 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.CreateAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UpdateAt", 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.UpdateAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field EndAt", 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.EndAt, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastRun", 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 err := github_com_gogo_protobuf_types.StdTimeUnmarshal(&m.LastRun, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			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
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			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")
)