base.form.pb.go

// Code generated by protoc-gen-go-form. DO NOT EDIT.
// Source: base.proto

package pb

import (
	base64 "encoding/base64"
	json "encoding/json"
	url "net/url"
	strconv "strconv"
	strings "strings"

	urlenc "github.com/erda-project/erda-infra/pkg/urlenc"
	pb "github.com/erda-project/erda-proto-go/common/pb"
	pb1 "github.com/erda-project/erda-proto-go/core/pipeline/cron/pb"
	pb2 "github.com/erda-project/erda-proto-go/core/pipeline/queue/pb"
	structpb "google.golang.org/protobuf/types/known/structpb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the "github.com/erda-project/erda-infra/pkg/urlenc" package it is being compiled against.
var _ urlenc.URLValuesUnmarshaler = (*PipelineSnippetQueryRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineSnippetQueryResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*SnippetDetailQuery)(nil)
var _ urlenc.URLValuesUnmarshaler = (*SnippetQueryDetail)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineInstance)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineExtra)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineInstanceDetail)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineGC)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineResourceGC)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineDatabaseGC)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineDBGCItem)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineRunParam)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineRunParamWithValue)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineUser)(nil)
var _ urlenc.URLValuesUnmarshaler = (*ShowMessage)(nil)
var _ urlenc.URLValuesUnmarshaler = (*StorageConfig)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineButton)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineExecuteRecord)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineEvent)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineEventSource)(nil)
var _ urlenc.URLValuesUnmarshaler = (*ErrorResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineOutput)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineOutputWithValue)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineParam)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineParamWithValue)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineYml)(nil)
var _ urlenc.URLValuesUnmarshaler = (*TriggerConfig)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PushTrigger)(nil)
var _ urlenc.URLValuesUnmarshaler = (*MergeTrigger)(nil)
var _ urlenc.URLValuesUnmarshaler = (*NetworkHookInfo)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineYmlAction)(nil)
var _ urlenc.URLValuesUnmarshaler = (*Resources)(nil)
var _ urlenc.URLValuesUnmarshaler = (*CronCompensator)(nil)
var _ urlenc.URLValuesUnmarshaler = (*ActionCache)(nil)
var _ urlenc.URLValuesUnmarshaler = (*TaskLoop)(nil)
var _ urlenc.URLValuesUnmarshaler = (*TaskLoopStrategy)(nil)
var _ urlenc.URLValuesUnmarshaler = (*SnippetStages)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineStage)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineStageDetail)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTask)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskExtra)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskResult)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskSnippetDetail)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskMachineStat)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskMachineHostStat)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskMachinePodStat)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskMachineLoadStat)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskMachineMemStat)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskMachineSwapStat)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskActionDetail)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineCreateRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineCreateResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelinePagingRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelinePagingResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineListResponseData)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PagePipeline)(nil)
var _ urlenc.URLValuesUnmarshaler = (*SnippetConfig)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineDetailRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineDetailResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskOperateRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineOperateRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineOperateResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineDeleteRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineDeleteResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineRunRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineRunResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineCancelRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineCancelResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineRerunRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineRerunResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineRerunFailedRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineRerunFailedResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskDetailRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskDetailResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskGetBootstrapInfoRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineTaskGetBootstrapInfoResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*DeprecatedPipelineBatchCreateRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*DeprecatedPipelineBatchCreateResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineYmlGraphRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineYmlGraphResponse)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineCallbackRequest)(nil)
var _ urlenc.URLValuesUnmarshaler = (*PipelineCallbackResponse)(nil)

// PipelineSnippetQueryRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineSnippetQueryRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	return nil
}

// PipelineSnippetQueryResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineSnippetQueryResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	return nil
}

// SnippetDetailQuery implement urlenc.URLValuesUnmarshaler.
func (m *SnippetDetailQuery) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "source":
				m.Source = vals[0]
			case "name":
				m.Name = vals[0]
			case "alias":
				m.Alias = vals[0]
			}
		}
	}
	return nil
}

// SnippetQueryDetail implement urlenc.URLValuesUnmarshaler.
func (m *SnippetQueryDetail) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "outputs":
				m.Outputs = vals
			}
		}
	}
	return nil
}

// PipelineInstance implement urlenc.URLValuesUnmarshaler.
func (m *PipelineInstance) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "ID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ID = val
			case "source":
				m.Source = vals[0]
			case "ymlName":
				m.YmlName = vals[0]
			case "namespace":
				m.Namespace = vals[0]
			case "clusterName":
				m.ClusterName = vals[0]
			case "status":
				m.Status = vals[0]
			case "type":
				m.Type = vals[0]
			case "triggerMode":
				m.TriggerMode = vals[0]
			case "cronID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CronID = val
			case "ymlSource":
				m.YmlSource = vals[0]
			case "ymlContent":
				m.YmlContent = vals[0]
			case "extra":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
			case "extra.diceWorkspace":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.DiceWorkspace = vals[0]
			case "extra.submitUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
			case "extra.submitUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.ID = vals[0]
			case "extra.submitUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.Name = vals[0]
			case "extra.submitUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.Avatar = vals[0]
			case "extra.runUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
			case "extra.runUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.ID = vals[0]
			case "extra.runUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.Name = vals[0]
			case "extra.runUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.Avatar = vals[0]
			case "extra.cancelUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
			case "extra.cancelUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.ID = vals[0]
			case "extra.cancelUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.Name = vals[0]
			case "extra.cancelUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.Avatar = vals[0]
			case "extra.cronExpr":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.CronExpr = vals[0]
			case "extra.cronTriggerTime":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
			case "extra.cronTriggerTime.seconds":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Extra.CronTriggerTime.Seconds = val
			case "extra.cronTriggerTime.nanos":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Extra.CronTriggerTime.Nanos = int32(val)
			case "extra.show_message":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
			case "extra.show_message.msg":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				m.Extra.ShowMessage.Msg = vals[0]
			case "extra.show_message.stacks":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				m.Extra.ShowMessage.Stacks = vals
			case "extra.show_message.abortRun":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Extra.ShowMessage.AbortRun = val
			case "extra.configManageNamespaces":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.ConfigManageNamespaces = vals
			case "extra.isAutoRun":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Extra.IsAutoRun = val
			case "extra.callbackURLs":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.CallbackURLs = vals
			case "orgID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.OrgID = val
			case "orgName":
				m.OrgName = vals[0]
			case "projectID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ProjectID = val
			case "projectName":
				m.ProjectName = vals[0]
			case "applicationID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ApplicationID = val
			case "applicationName":
				m.ApplicationName = vals[0]
			case "branch":
				m.Branch = vals[0]
			case "commit":
				m.Commit = vals[0]
			case "commitDetail":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
			case "commitDetail.commitID":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.CommitID = vals[0]
			case "commitDetail.repo":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.Repo = vals[0]
			case "commitDetail.repoAbbr":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.RepoAbbr = vals[0]
			case "commitDetail.author":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.Author = vals[0]
			case "commitDetail.email":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.Email = vals[0]
			case "commitDetail.time":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				if m.CommitDetail.Time == nil {
					m.CommitDetail.Time = &timestamppb.Timestamp{}
				}
			case "commitDetail.time.seconds":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				if m.CommitDetail.Time == nil {
					m.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CommitDetail.Time.Seconds = val
			case "commitDetail.time.nanos":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				if m.CommitDetail.Time == nil {
					m.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.CommitDetail.Time.Nanos = int32(val)
			case "commitDetail.comment":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.Comment = vals[0]
			case "progress":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Progress = val
			case "costTimeSec":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CostTimeSec = val
			case "timeBegin":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
			case "timeBegin.seconds":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeBegin.Seconds = val
			case "timeBegin.nanos":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeBegin.Nanos = int32(val)
			case "timeEnd":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
			case "timeEnd.seconds":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeEnd.Seconds = val
			case "timeEnd.nanos":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeEnd.Nanos = int32(val)
			case "timeCreated":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
			case "timeCreated.seconds":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeCreated.Seconds = val
			case "timeCreated.nanos":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeCreated.Nanos = int32(val)
			case "timeUpdated":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "timeUpdated.seconds":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeUpdated.Seconds = val
			case "timeUpdated.nanos":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelineExtra implement urlenc.URLValuesUnmarshaler.
func (m *PipelineExtra) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "diceWorkspace":
				m.DiceWorkspace = vals[0]
			case "submitUser":
				if m.SubmitUser == nil {
					m.SubmitUser = &PipelineUser{}
				}
			case "submitUser.ID":
				if m.SubmitUser == nil {
					m.SubmitUser = &PipelineUser{}
				}
				m.SubmitUser.ID = vals[0]
			case "submitUser.name":
				if m.SubmitUser == nil {
					m.SubmitUser = &PipelineUser{}
				}
				m.SubmitUser.Name = vals[0]
			case "submitUser.avatar":
				if m.SubmitUser == nil {
					m.SubmitUser = &PipelineUser{}
				}
				m.SubmitUser.Avatar = vals[0]
			case "runUser":
				if m.RunUser == nil {
					m.RunUser = &PipelineUser{}
				}
			case "runUser.ID":
				if m.RunUser == nil {
					m.RunUser = &PipelineUser{}
				}
				m.RunUser.ID = vals[0]
			case "runUser.name":
				if m.RunUser == nil {
					m.RunUser = &PipelineUser{}
				}
				m.RunUser.Name = vals[0]
			case "runUser.avatar":
				if m.RunUser == nil {
					m.RunUser = &PipelineUser{}
				}
				m.RunUser.Avatar = vals[0]
			case "cancelUser":
				if m.CancelUser == nil {
					m.CancelUser = &PipelineUser{}
				}
			case "cancelUser.ID":
				if m.CancelUser == nil {
					m.CancelUser = &PipelineUser{}
				}
				m.CancelUser.ID = vals[0]
			case "cancelUser.name":
				if m.CancelUser == nil {
					m.CancelUser = &PipelineUser{}
				}
				m.CancelUser.Name = vals[0]
			case "cancelUser.avatar":
				if m.CancelUser == nil {
					m.CancelUser = &PipelineUser{}
				}
				m.CancelUser.Avatar = vals[0]
			case "cronExpr":
				m.CronExpr = vals[0]
			case "cronTriggerTime":
				if m.CronTriggerTime == nil {
					m.CronTriggerTime = &timestamppb.Timestamp{}
				}
			case "cronTriggerTime.seconds":
				if m.CronTriggerTime == nil {
					m.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CronTriggerTime.Seconds = val
			case "cronTriggerTime.nanos":
				if m.CronTriggerTime == nil {
					m.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.CronTriggerTime.Nanos = int32(val)
			case "show_message":
				if m.ShowMessage == nil {
					m.ShowMessage = &ShowMessage{}
				}
			case "show_message.msg":
				if m.ShowMessage == nil {
					m.ShowMessage = &ShowMessage{}
				}
				m.ShowMessage.Msg = vals[0]
			case "show_message.stacks":
				if m.ShowMessage == nil {
					m.ShowMessage = &ShowMessage{}
				}
				m.ShowMessage.Stacks = vals
			case "show_message.abortRun":
				if m.ShowMessage == nil {
					m.ShowMessage = &ShowMessage{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.ShowMessage.AbortRun = val
			case "configManageNamespaces":
				m.ConfigManageNamespaces = vals
			case "isAutoRun":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.IsAutoRun = val
			case "callbackURLs":
				m.CallbackURLs = vals
			}
		}
	}
	return nil
}

// PipelineInstanceDetail implement urlenc.URLValuesUnmarshaler.
func (m *PipelineInstanceDetail) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "ID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ID = val
			case "source":
				m.Source = vals[0]
			case "ymlName":
				m.YmlName = vals[0]
			case "namespace":
				m.Namespace = vals[0]
			case "clusterName":
				m.ClusterName = vals[0]
			case "status":
				m.Status = vals[0]
			case "type":
				m.Type = vals[0]
			case "triggerMode":
				m.TriggerMode = vals[0]
			case "cronID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CronID = val
			case "ymlSource":
				m.YmlSource = vals[0]
			case "ymlContent":
				m.YmlContent = vals[0]
			case "extra":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
			case "extra.diceWorkspace":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.DiceWorkspace = vals[0]
			case "extra.submitUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
			case "extra.submitUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.ID = vals[0]
			case "extra.submitUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.Name = vals[0]
			case "extra.submitUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.Avatar = vals[0]
			case "extra.runUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
			case "extra.runUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.ID = vals[0]
			case "extra.runUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.Name = vals[0]
			case "extra.runUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.Avatar = vals[0]
			case "extra.cancelUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
			case "extra.cancelUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.ID = vals[0]
			case "extra.cancelUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.Name = vals[0]
			case "extra.cancelUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.Avatar = vals[0]
			case "extra.cronExpr":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.CronExpr = vals[0]
			case "extra.cronTriggerTime":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
			case "extra.cronTriggerTime.seconds":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Extra.CronTriggerTime.Seconds = val
			case "extra.cronTriggerTime.nanos":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Extra.CronTriggerTime.Nanos = int32(val)
			case "extra.show_message":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
			case "extra.show_message.msg":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				m.Extra.ShowMessage.Msg = vals[0]
			case "extra.show_message.stacks":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				m.Extra.ShowMessage.Stacks = vals
			case "extra.show_message.abortRun":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Extra.ShowMessage.AbortRun = val
			case "extra.configManageNamespaces":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.ConfigManageNamespaces = vals
			case "extra.isAutoRun":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Extra.IsAutoRun = val
			case "extra.callbackURLs":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.CallbackURLs = vals
			case "orgID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.OrgID = val
			case "orgName":
				m.OrgName = vals[0]
			case "projectID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ProjectID = val
			case "projectName":
				m.ProjectName = vals[0]
			case "applicationID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ApplicationID = val
			case "applicationName":
				m.ApplicationName = vals[0]
			case "branch":
				m.Branch = vals[0]
			case "commit":
				m.Commit = vals[0]
			case "commitDetail":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
			case "commitDetail.commitID":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.CommitID = vals[0]
			case "commitDetail.repo":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.Repo = vals[0]
			case "commitDetail.repoAbbr":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.RepoAbbr = vals[0]
			case "commitDetail.author":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.Author = vals[0]
			case "commitDetail.email":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.Email = vals[0]
			case "commitDetail.time":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				if m.CommitDetail.Time == nil {
					m.CommitDetail.Time = &timestamppb.Timestamp{}
				}
			case "commitDetail.time.seconds":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				if m.CommitDetail.Time == nil {
					m.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CommitDetail.Time.Seconds = val
			case "commitDetail.time.nanos":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				if m.CommitDetail.Time == nil {
					m.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.CommitDetail.Time.Nanos = int32(val)
			case "commitDetail.comment":
				if m.CommitDetail == nil {
					m.CommitDetail = &pb.CommitDetail{}
				}
				m.CommitDetail.Comment = vals[0]
			case "progress":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Progress = val
			case "costTimeSec":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CostTimeSec = val
			case "timeBegin":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
			case "timeBegin.seconds":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeBegin.Seconds = val
			case "timeBegin.nanos":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeBegin.Nanos = int32(val)
			case "timeEnd":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
			case "timeEnd.seconds":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeEnd.Seconds = val
			case "timeEnd.nanos":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeEnd.Nanos = int32(val)
			case "timeCreated":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
			case "timeCreated.seconds":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeCreated.Seconds = val
			case "timeCreated.nanos":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeCreated.Nanos = int32(val)
			case "timeUpdated":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "timeUpdated.seconds":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeUpdated.Seconds = val
			case "timeUpdated.nanos":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeUpdated.Nanos = int32(val)
			case "pipelineCron":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
			case "pipelineCron.ID":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineCron.ID = val
			case "pipelineCron.timeCreated":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.TimeCreated == nil {
					m.PipelineCron.TimeCreated = &timestamppb.Timestamp{}
				}
			case "pipelineCron.timeCreated.seconds":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.TimeCreated == nil {
					m.PipelineCron.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineCron.TimeCreated.Seconds = val
			case "pipelineCron.timeCreated.nanos":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.TimeCreated == nil {
					m.PipelineCron.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.PipelineCron.TimeCreated.Nanos = int32(val)
			case "pipelineCron.timeUpdated":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.TimeUpdated == nil {
					m.PipelineCron.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "pipelineCron.timeUpdated.seconds":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.TimeUpdated == nil {
					m.PipelineCron.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineCron.TimeUpdated.Seconds = val
			case "pipelineCron.timeUpdated.nanos":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.TimeUpdated == nil {
					m.PipelineCron.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.PipelineCron.TimeUpdated.Nanos = int32(val)
			case "pipelineCron.cronExpr":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				m.PipelineCron.CronExpr = vals[0]
			case "pipelineCron.cronStartTime":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.CronStartTime == nil {
					m.PipelineCron.CronStartTime = &timestamppb.Timestamp{}
				}
			case "pipelineCron.cronStartTime.seconds":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.CronStartTime == nil {
					m.PipelineCron.CronStartTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineCron.CronStartTime.Seconds = val
			case "pipelineCron.cronStartTime.nanos":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				if m.PipelineCron.CronStartTime == nil {
					m.PipelineCron.CronStartTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.PipelineCron.CronStartTime.Nanos = int32(val)
			case "pipelineCron.pipelineYmlName":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				m.PipelineCron.PipelineYmlName = vals[0]
			case "pipelineCron.enable":
				if m.PipelineCron == nil {
					m.PipelineCron = &pb1.Cron{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineCron.Enable = val
			case "pipelineButton":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
			case "pipelineButton.canManualRun":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanManualRun = val
			case "pipelineButton.canCancel":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanCancel = val
			case "pipelineButton.canForceCancel":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanForceCancel = val
			case "pipelineButton.canRerun":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanRerun = val
			case "pipelineButton.canRerunFailed":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanRerunFailed = val
			case "pipelineButton.canStartCron":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanStartCron = val
			case "pipelineButton.canStopCron":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanStopCron = val
			case "pipelineButton.canPause":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanPause = val
			case "pipelineButton.canUnpause":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanUnpause = val
			case "pipelineButton.canDelete":
				if m.PipelineButton == nil {
					m.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.PipelineButton.CanDelete = val
			case "needApproval":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.NeedApproval = val
			}
		}
	}
	return nil
}

// PipelineGC implement urlenc.URLValuesUnmarshaler.
func (m *PipelineGC) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "resourceGC":
				if m.ResourceGC == nil {
					m.ResourceGC = &PipelineResourceGC{}
				}
			case "resourceGC.successTTLSecond":
				if m.ResourceGC == nil {
					m.ResourceGC = &PipelineResourceGC{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ResourceGC.SuccessTTLSecond = val
			case "resourceGC.failedTTLSecond":
				if m.ResourceGC == nil {
					m.ResourceGC = &PipelineResourceGC{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ResourceGC.FailedTTLSecond = val
			case "databaseGC":
				if m.DatabaseGC == nil {
					m.DatabaseGC = &PipelineDatabaseGC{}
				}
			case "databaseGC.analyzed":
				if m.DatabaseGC == nil {
					m.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.DatabaseGC.Analyzed == nil {
					m.DatabaseGC.Analyzed = &PipelineDBGCItem{}
				}
			case "databaseGC.analyzed.needArchive":
				if m.DatabaseGC == nil {
					m.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.DatabaseGC.Analyzed == nil {
					m.DatabaseGC.Analyzed = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.DatabaseGC.Analyzed.NeedArchive = val
			case "databaseGC.analyzed.TTLSecond":
				if m.DatabaseGC == nil {
					m.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.DatabaseGC.Analyzed == nil {
					m.DatabaseGC.Analyzed = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.DatabaseGC.Analyzed.TTLSecond = val
			case "databaseGC.finished":
				if m.DatabaseGC == nil {
					m.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.DatabaseGC.Finished == nil {
					m.DatabaseGC.Finished = &PipelineDBGCItem{}
				}
			case "databaseGC.finished.needArchive":
				if m.DatabaseGC == nil {
					m.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.DatabaseGC.Finished == nil {
					m.DatabaseGC.Finished = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.DatabaseGC.Finished.NeedArchive = val
			case "databaseGC.finished.TTLSecond":
				if m.DatabaseGC == nil {
					m.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.DatabaseGC.Finished == nil {
					m.DatabaseGC.Finished = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.DatabaseGC.Finished.TTLSecond = val
			}
		}
	}
	return nil
}

// PipelineResourceGC implement urlenc.URLValuesUnmarshaler.
func (m *PipelineResourceGC) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "successTTLSecond":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.SuccessTTLSecond = val
			case "failedTTLSecond":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.FailedTTLSecond = val
			}
		}
	}
	return nil
}

// PipelineDatabaseGC implement urlenc.URLValuesUnmarshaler.
func (m *PipelineDatabaseGC) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "analyzed":
				if m.Analyzed == nil {
					m.Analyzed = &PipelineDBGCItem{}
				}
			case "analyzed.needArchive":
				if m.Analyzed == nil {
					m.Analyzed = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Analyzed.NeedArchive = val
			case "analyzed.TTLSecond":
				if m.Analyzed == nil {
					m.Analyzed = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Analyzed.TTLSecond = val
			case "finished":
				if m.Finished == nil {
					m.Finished = &PipelineDBGCItem{}
				}
			case "finished.needArchive":
				if m.Finished == nil {
					m.Finished = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Finished.NeedArchive = val
			case "finished.TTLSecond":
				if m.Finished == nil {
					m.Finished = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Finished.TTLSecond = val
			}
		}
	}
	return nil
}

// PipelineDBGCItem implement urlenc.URLValuesUnmarshaler.
func (m *PipelineDBGCItem) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "needArchive":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.NeedArchive = val
			case "TTLSecond":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TTLSecond = val
			}
		}
	}
	return nil
}

// PipelineRunParam implement urlenc.URLValuesUnmarshaler.
func (m *PipelineRunParam) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "name":
				m.Name = vals[0]
			case "value":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Value = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Value = val
					} else {
						m.Value = structpb.NewStringValue(vals[0])
					}
				}
			}
		}
	}
	return nil
}

// PipelineRunParamWithValue implement urlenc.URLValuesUnmarshaler.
func (m *PipelineRunParamWithValue) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "name":
				m.Name = vals[0]
			case "value":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Value = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Value = val
					} else {
						m.Value = structpb.NewStringValue(vals[0])
					}
				}
			case "trueValue":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.TrueValue = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.TrueValue = val
					} else {
						m.TrueValue = structpb.NewStringValue(vals[0])
					}
				}
			}
		}
	}
	return nil
}

// PipelineUser implement urlenc.URLValuesUnmarshaler.
func (m *PipelineUser) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "ID":
				m.ID = vals[0]
			case "name":
				m.Name = vals[0]
			case "avatar":
				m.Avatar = vals[0]
			}
		}
	}
	return nil
}

// ShowMessage implement urlenc.URLValuesUnmarshaler.
func (m *ShowMessage) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "msg":
				m.Msg = vals[0]
			case "stacks":
				m.Stacks = vals
			case "abortRun":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AbortRun = val
			}
		}
	}
	return nil
}

// StorageConfig implement urlenc.URLValuesUnmarshaler.
func (m *StorageConfig) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "enableNFS":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.EnableNFS = val
			case "enableLocal":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.EnableLocal = val
			}
		}
	}
	return nil
}

// PipelineButton implement urlenc.URLValuesUnmarshaler.
func (m *PipelineButton) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "canManualRun":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanManualRun = val
			case "canCancel":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanCancel = val
			case "canForceCancel":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanForceCancel = val
			case "canRerun":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanRerun = val
			case "canRerunFailed":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanRerunFailed = val
			case "canStartCron":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanStartCron = val
			case "canStopCron":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanStopCron = val
			case "canPause":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanPause = val
			case "canUnpause":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanUnpause = val
			case "canDelete":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CanDelete = val
			}
		}
	}
	return nil
}

// PipelineExecuteRecord implement urlenc.URLValuesUnmarshaler.
func (m *PipelineExecuteRecord) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "PipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "status":
				m.Status = vals[0]
			case "triggerMode":
				m.TriggerMode = vals[0]
			case "timeCreated":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
			case "timeCreated.seconds":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeCreated.Seconds = val
			case "timeCreated.nanos":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeCreated.Nanos = int32(val)
			case "timeBegin":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
			case "timeBegin.seconds":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeBegin.Seconds = val
			case "timeBegin.nanos":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeBegin.Nanos = int32(val)
			case "timeEnd":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
			case "timeEnd.seconds":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeEnd.Seconds = val
			case "timeEnd.nanos":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeEnd.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelineEvent implement urlenc.URLValuesUnmarshaler.
func (m *PipelineEvent) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "reason":
				m.Reason = vals[0]
			case "message":
				m.Message = vals[0]
			case "source":
				if m.Source == nil {
					m.Source = &PipelineEventSource{}
				}
			case "source.component":
				if m.Source == nil {
					m.Source = &PipelineEventSource{}
				}
				m.Source.Component = vals[0]
			case "source.host":
				if m.Source == nil {
					m.Source = &PipelineEventSource{}
				}
				m.Source.Host = vals[0]
			case "firstTimestamp":
				if m.FirstTimestamp == nil {
					m.FirstTimestamp = &timestamppb.Timestamp{}
				}
			case "firstTimestamp.seconds":
				if m.FirstTimestamp == nil {
					m.FirstTimestamp = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.FirstTimestamp.Seconds = val
			case "firstTimestamp.nanos":
				if m.FirstTimestamp == nil {
					m.FirstTimestamp = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.FirstTimestamp.Nanos = int32(val)
			case "lastTimestamp":
				if m.LastTimestamp == nil {
					m.LastTimestamp = &timestamppb.Timestamp{}
				}
			case "lastTimestamp.seconds":
				if m.LastTimestamp == nil {
					m.LastTimestamp = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.LastTimestamp.Seconds = val
			case "lastTimestamp.nanos":
				if m.LastTimestamp == nil {
					m.LastTimestamp = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.LastTimestamp.Nanos = int32(val)
			case "count":
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Count = int32(val)
			case "type":
				m.Type = vals[0]
			}
		}
	}
	return nil
}

// PipelineEventSource implement urlenc.URLValuesUnmarshaler.
func (m *PipelineEventSource) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "component":
				m.Component = vals[0]
			case "host":
				m.Host = vals[0]
			}
		}
	}
	return nil
}

// ErrorResponse implement urlenc.URLValuesUnmarshaler.
func (m *ErrorResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "code":
				m.Code = vals[0]
			case "msg":
				m.Msg = vals[0]
			case "ctx":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Ctx = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Ctx = val
					} else {
						m.Ctx = structpb.NewStringValue(vals[0])
					}
				}
			}
		}
	}
	return nil
}

// PipelineOutput implement urlenc.URLValuesUnmarshaler.
func (m *PipelineOutput) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "name":
				m.Name = vals[0]
			case "desc":
				m.Desc = vals[0]
			case "ref":
				m.Ref = vals[0]
			}
		}
	}
	return nil
}

// PipelineOutputWithValue implement urlenc.URLValuesUnmarshaler.
func (m *PipelineOutputWithValue) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "name":
				m.Name = vals[0]
			case "desc":
				m.Desc = vals[0]
			case "ref":
				m.Ref = vals[0]
			case "value":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Value = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Value = val
					} else {
						m.Value = structpb.NewStringValue(vals[0])
					}
				}
			}
		}
	}
	return nil
}

// PipelineParam implement urlenc.URLValuesUnmarshaler.
func (m *PipelineParam) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "name":
				m.Name = vals[0]
			case "required":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Required = val
			case "default":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Default = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Default = val
					} else {
						m.Default = structpb.NewStringValue(vals[0])
					}
				}
			case "desc":
				m.Desc = vals[0]
			case "type":
				m.Type = vals[0]
			}
		}
	}
	return nil
}

// PipelineParamWithValue implement urlenc.URLValuesUnmarshaler.
func (m *PipelineParamWithValue) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "name":
				m.Name = vals[0]
			case "required":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Required = val
			case "default":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Default = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Default = val
					} else {
						m.Default = structpb.NewStringValue(vals[0])
					}
				}
			case "desc":
				m.Desc = vals[0]
			case "type":
				m.Type = vals[0]
			case "value":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Value = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Value = val
					} else {
						m.Value = structpb.NewStringValue(vals[0])
					}
				}
			}
		}
	}
	return nil
}

// PipelineYml implement urlenc.URLValuesUnmarshaler.
func (m *PipelineYml) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "version":
				m.Version = vals[0]
			case "cron":
				m.Cron = vals[0]
			case "cronCompensator":
				if m.CronCompensator == nil {
					m.CronCompensator = &CronCompensator{}
				}
			case "cronCompensator.enable":
				if m.CronCompensator == nil {
					m.CronCompensator = &CronCompensator{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CronCompensator.Enable = val
			case "cronCompensator.latestFirst":
				if m.CronCompensator == nil {
					m.CronCompensator = &CronCompensator{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CronCompensator.LatestFirst = val
			case "cronCompensator.stopIfLatterExecuted":
				if m.CronCompensator == nil {
					m.CronCompensator = &CronCompensator{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CronCompensator.StopIfLatterExecuted = val
			case "stages":
				if m.Stages == nil {
					m.Stages = &structpb.ListValue{}
				}
			case "needUpgrade":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.NeedUpgrade = val
			case "ymlContent":
				m.YmlContent = vals[0]
			case "on":
				if m.On == nil {
					m.On = &TriggerConfig{}
				}
			case "on.push":
				if m.On == nil {
					m.On = &TriggerConfig{}
				}
				if m.On.Push == nil {
					m.On.Push = &PushTrigger{}
				}
			case "on.push.branches":
				if m.On == nil {
					m.On = &TriggerConfig{}
				}
				if m.On.Push == nil {
					m.On.Push = &PushTrigger{}
				}
				m.On.Push.Branches = vals
			case "on.push.tags":
				if m.On == nil {
					m.On = &TriggerConfig{}
				}
				if m.On.Push == nil {
					m.On.Push = &PushTrigger{}
				}
				m.On.Push.Tags = vals
			case "on.merge":
				if m.On == nil {
					m.On = &TriggerConfig{}
				}
				if m.On.Merge == nil {
					m.On.Merge = &MergeTrigger{}
				}
			case "on.merge.branches":
				if m.On == nil {
					m.On = &TriggerConfig{}
				}
				if m.On.Merge == nil {
					m.On.Merge = &MergeTrigger{}
				}
				m.On.Merge.Branches = vals
			}
		}
	}
	return nil
}

// TriggerConfig implement urlenc.URLValuesUnmarshaler.
func (m *TriggerConfig) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "push":
				if m.Push == nil {
					m.Push = &PushTrigger{}
				}
			case "push.branches":
				if m.Push == nil {
					m.Push = &PushTrigger{}
				}
				m.Push.Branches = vals
			case "push.tags":
				if m.Push == nil {
					m.Push = &PushTrigger{}
				}
				m.Push.Tags = vals
			case "merge":
				if m.Merge == nil {
					m.Merge = &MergeTrigger{}
				}
			case "merge.branches":
				if m.Merge == nil {
					m.Merge = &MergeTrigger{}
				}
				m.Merge.Branches = vals
			}
		}
	}
	return nil
}

// PushTrigger implement urlenc.URLValuesUnmarshaler.
func (m *PushTrigger) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "branches":
				m.Branches = vals
			case "tags":
				m.Tags = vals
			}
		}
	}
	return nil
}

// MergeTrigger implement urlenc.URLValuesUnmarshaler.
func (m *MergeTrigger) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "branches":
				m.Branches = vals
			}
		}
	}
	return nil
}

// NetworkHookInfo implement urlenc.URLValuesUnmarshaler.
func (m *NetworkHookInfo) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "hook":
				m.Hook = vals[0]
			case "client":
				m.Client = vals[0]
			}
		}
	}
	return nil
}

// PipelineYmlAction implement urlenc.URLValuesUnmarshaler.
func (m *PipelineYmlAction) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "alias":
				m.Alias = vals[0]
			case "type":
				m.Type = vals[0]
			case "description":
				m.Description = vals[0]
			case "version":
				m.Version = vals[0]
			case "image":
				m.Image = vals[0]
			case "commands":
				m.Commands = vals
			case "timeout":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Timeout = val
			case "namespaces":
				m.Namespaces = vals
			case "resources":
				if m.Resources == nil {
					m.Resources = &Resources{}
				}
			case "resources.cpu":
				if m.Resources == nil {
					m.Resources = &Resources{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Resources.Cpu = val
			case "resources.mem":
				if m.Resources == nil {
					m.Resources = &Resources{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Resources.Mem = val
			case "resources.disk":
				if m.Resources == nil {
					m.Resources = &Resources{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Resources.Disk = val
			case "displayName":
				m.DisplayName = vals[0]
			case "logoUrl":
				m.LogoUrl = vals[0]
			case "snippetConfig":
				if m.SnippetConfig == nil {
					m.SnippetConfig = &SnippetConfig{}
				}
			case "snippetConfig.source":
				if m.SnippetConfig == nil {
					m.SnippetConfig = &SnippetConfig{}
				}
				m.SnippetConfig.Source = vals[0]
			case "snippetConfig.name":
				if m.SnippetConfig == nil {
					m.SnippetConfig = &SnippetConfig{}
				}
				m.SnippetConfig.Name = vals[0]
			case "if":
				m.If = vals[0]
			case "loop":
				if m.Loop == nil {
					m.Loop = &TaskLoop{}
				}
			case "loop.break":
				if m.Loop == nil {
					m.Loop = &TaskLoop{}
				}
				m.Loop.Break = vals[0]
			case "loop.strategy":
				if m.Loop == nil {
					m.Loop = &TaskLoop{}
				}
				if m.Loop.Strategy == nil {
					m.Loop.Strategy = &TaskLoopStrategy{}
				}
			case "loop.strategy.maxTimes":
				if m.Loop == nil {
					m.Loop = &TaskLoop{}
				}
				if m.Loop.Strategy == nil {
					m.Loop.Strategy = &TaskLoopStrategy{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Loop.Strategy.MaxTimes = val
			case "loop.strategy.declineRatio":
				if m.Loop == nil {
					m.Loop = &TaskLoop{}
				}
				if m.Loop.Strategy == nil {
					m.Loop.Strategy = &TaskLoopStrategy{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Loop.Strategy.DeclineRatio = val
			case "loop.strategy.declineLimitSec":
				if m.Loop == nil {
					m.Loop = &TaskLoop{}
				}
				if m.Loop.Strategy == nil {
					m.Loop.Strategy = &TaskLoopStrategy{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Loop.Strategy.DeclineLimitSec = val
			case "loop.strategy.intervalSec":
				if m.Loop == nil {
					m.Loop = &TaskLoop{}
				}
				if m.Loop.Strategy == nil {
					m.Loop.Strategy = &TaskLoopStrategy{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Loop.Strategy.IntervalSec = val
			case "snippetStages":
				if m.SnippetStages == nil {
					m.SnippetStages = &SnippetStages{}
				}
			case "snippetStages.stages":
				if m.SnippetStages == nil {
					m.SnippetStages = &SnippetStages{}
				}
				if m.SnippetStages.Stages == nil {
					m.SnippetStages.Stages = &structpb.ListValue{}
				}
			}
		}
	}
	return nil
}

// Resources implement urlenc.URLValuesUnmarshaler.
func (m *Resources) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "cpu":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Cpu = val
			case "mem":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Mem = val
			case "disk":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Disk = val
			}
		}
	}
	return nil
}

// CronCompensator implement urlenc.URLValuesUnmarshaler.
func (m *CronCompensator) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "enable":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Enable = val
			case "latestFirst":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.LatestFirst = val
			case "stopIfLatterExecuted":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.StopIfLatterExecuted = val
			}
		}
	}
	return nil
}

// ActionCache implement urlenc.URLValuesUnmarshaler.
func (m *ActionCache) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "key":
				m.Key = vals[0]
			case "path":
				m.Path = vals[0]
			}
		}
	}
	return nil
}

// TaskLoop implement urlenc.URLValuesUnmarshaler.
func (m *TaskLoop) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "break":
				m.Break = vals[0]
			case "strategy":
				if m.Strategy == nil {
					m.Strategy = &TaskLoopStrategy{}
				}
			case "strategy.maxTimes":
				if m.Strategy == nil {
					m.Strategy = &TaskLoopStrategy{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Strategy.MaxTimes = val
			case "strategy.declineRatio":
				if m.Strategy == nil {
					m.Strategy = &TaskLoopStrategy{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Strategy.DeclineRatio = val
			case "strategy.declineLimitSec":
				if m.Strategy == nil {
					m.Strategy = &TaskLoopStrategy{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Strategy.DeclineLimitSec = val
			case "strategy.intervalSec":
				if m.Strategy == nil {
					m.Strategy = &TaskLoopStrategy{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Strategy.IntervalSec = val
			}
		}
	}
	return nil
}

// TaskLoopStrategy implement urlenc.URLValuesUnmarshaler.
func (m *TaskLoopStrategy) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "maxTimes":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MaxTimes = val
			case "declineRatio":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.DeclineRatio = val
			case "declineLimitSec":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.DeclineLimitSec = val
			case "intervalSec":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.IntervalSec = val
			}
		}
	}
	return nil
}

// SnippetStages implement urlenc.URLValuesUnmarshaler.
func (m *SnippetStages) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "stages":
				if m.Stages == nil {
					m.Stages = &structpb.ListValue{}
				}
			}
		}
	}
	return nil
}

// PipelineStage implement urlenc.URLValuesUnmarshaler.
func (m *PipelineStage) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "ID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ID = val
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "name":
				m.Name = vals[0]
			case "status":
				m.Status = vals[0]
			case "costTimeSec":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CostTimeSec = val
			case "timeBegin":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
			case "timeBegin.seconds":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeBegin.Seconds = val
			case "timeBegin.nanos":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeBegin.Nanos = int32(val)
			case "timeEnd":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
			case "timeEnd.seconds":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeEnd.Seconds = val
			case "timeEnd.nanos":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeEnd.Nanos = int32(val)
			case "timeCreated":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
			case "timeCreated.seconds":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeCreated.Seconds = val
			case "timeCreated.nanos":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeCreated.Nanos = int32(val)
			case "timeUpdated":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "timeUpdated.seconds":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeUpdated.Seconds = val
			case "timeUpdated.nanos":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelineStageDetail implement urlenc.URLValuesUnmarshaler.
func (m *PipelineStageDetail) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "ID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ID = val
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "name":
				m.Name = vals[0]
			case "status":
				m.Status = vals[0]
			case "costTimeSec":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CostTimeSec = val
			case "timeBegin":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
			case "timeBegin.seconds":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeBegin.Seconds = val
			case "timeBegin.nanos":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeBegin.Nanos = int32(val)
			case "timeEnd":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
			case "timeEnd.seconds":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeEnd.Seconds = val
			case "timeEnd.nanos":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeEnd.Nanos = int32(val)
			case "timeCreated":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
			case "timeCreated.seconds":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeCreated.Seconds = val
			case "timeCreated.nanos":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeCreated.Nanos = int32(val)
			case "timeUpdated":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "timeUpdated.seconds":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeUpdated.Seconds = val
			case "timeUpdated.nanos":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelineTask implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTask) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "ID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ID = val
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "stageID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.StageID = val
			case "name":
				m.Name = vals[0]
			case "type":
				m.Type = vals[0]
			case "status":
				m.Status = vals[0]
			case "extra":
				if m.Extra == nil {
					m.Extra = &PipelineTaskExtra{}
				}
			case "extra.UUID":
				if m.Extra == nil {
					m.Extra = &PipelineTaskExtra{}
				}
				m.Extra.UUID = vals[0]
			case "extra.allowFailure":
				if m.Extra == nil {
					m.Extra = &PipelineTaskExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Extra.AllowFailure = val
			case "result":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
			case "result.machineStat":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
			case "result.machineStat.host":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
			case "result.machineStat.host.hostIP":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Result.MachineStat.Host.HostIP = vals[0]
			case "result.machineStat.host.hostname":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Result.MachineStat.Host.Hostname = vals[0]
			case "result.machineStat.host.uptimeSec":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Host.UptimeSec = val
			case "result.machineStat.host.bootTimeSec":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Host.BootTimeSec = val
			case "result.machineStat.host.OS":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Result.MachineStat.Host.OS = vals[0]
			case "result.machineStat.host.platform":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Result.MachineStat.Host.Platform = vals[0]
			case "result.machineStat.host.platformVersion":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Result.MachineStat.Host.PlatformVersion = vals[0]
			case "result.machineStat.host.kernelVersion":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Result.MachineStat.Host.KernelVersion = vals[0]
			case "result.machineStat.host.kernelArch":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Host == nil {
					m.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Result.MachineStat.Host.KernelArch = vals[0]
			case "result.machineStat.pod":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Pod == nil {
					m.Result.MachineStat.Pod = &PipelineTaskMachinePodStat{}
				}
			case "result.machineStat.pod.podIP":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Pod == nil {
					m.Result.MachineStat.Pod = &PipelineTaskMachinePodStat{}
				}
				m.Result.MachineStat.Pod.PodIP = vals[0]
			case "result.machineStat.load":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Load == nil {
					m.Result.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
			case "result.machineStat.load.load1":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Load == nil {
					m.Result.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Load.Load1 = val
			case "result.machineStat.load.load5":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Load == nil {
					m.Result.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Load.Load5 = val
			case "result.machineStat.load.load15":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Load == nil {
					m.Result.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Load.Load15 = val
			case "result.machineStat.mem":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Mem == nil {
					m.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
			case "result.machineStat.mem.total":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Mem == nil {
					m.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Mem.Total = val
			case "result.machineStat.mem.available":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Mem == nil {
					m.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Mem.Available = val
			case "result.machineStat.mem.used":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Mem == nil {
					m.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Mem.Used = val
			case "result.machineStat.mem.free":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Mem == nil {
					m.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Mem.Free = val
			case "result.machineStat.mem.usedPercent":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Mem == nil {
					m.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Mem.UsedPercent = val
			case "result.machineStat.mem.buffers":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Mem == nil {
					m.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Mem.Buffers = val
			case "result.machineStat.mem.cached":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Mem == nil {
					m.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Mem.Cached = val
			case "result.machineStat.swap":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Swap == nil {
					m.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
			case "result.machineStat.swap.total":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Swap == nil {
					m.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Swap.Total = val
			case "result.machineStat.swap.used":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Swap == nil {
					m.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Swap.Used = val
			case "result.machineStat.swap.free":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Swap == nil {
					m.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Swap.Free = val
			case "result.machineStat.swap.usedPercent":
				if m.Result == nil {
					m.Result = &PipelineTaskResult{}
				}
				if m.Result.MachineStat == nil {
					m.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Result.MachineStat.Swap == nil {
					m.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Result.MachineStat.Swap.UsedPercent = val
			case "isSnippet":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.IsSnippet = val
			case "snippetPipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.SnippetPipelineID = val
			case "snippetPipelineDetail":
				if m.SnippetPipelineDetail == nil {
					m.SnippetPipelineDetail = &PipelineTaskSnippetDetail{}
				}
			case "snippetPipelineDetail.directSnippetTaskNum":
				if m.SnippetPipelineDetail == nil {
					m.SnippetPipelineDetail = &PipelineTaskSnippetDetail{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.SnippetPipelineDetail.DirectSnippetTaskNum = val
			case "snippetPipelineDetail.recursiveSnippetTaskNum":
				if m.SnippetPipelineDetail == nil {
					m.SnippetPipelineDetail = &PipelineTaskSnippetDetail{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.SnippetPipelineDetail.RecursiveSnippetTaskNum = val
			case "costTimeSec":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CostTimeSec = val
			case "queueTimeSec":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.QueueTimeSec = val
			case "timeBegin":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
			case "timeBegin.seconds":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeBegin.Seconds = val
			case "timeBegin.nanos":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeBegin.Nanos = int32(val)
			case "timeEnd":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
			case "timeEnd.seconds":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeEnd.Seconds = val
			case "timeEnd.nanos":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeEnd.Nanos = int32(val)
			case "timeCreated":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
			case "timeCreated.seconds":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeCreated.Seconds = val
			case "timeCreated.nanos":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeCreated.Nanos = int32(val)
			case "timeUpdated":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "timeUpdated.seconds":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeUpdated.Seconds = val
			case "timeUpdated.nanos":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelineTaskExtra implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskExtra) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "UUID":
				m.UUID = vals[0]
			case "allowFailure":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AllowFailure = val
			}
		}
	}
	return nil
}

// PipelineTaskResult implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskResult) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "machineStat":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
			case "machineStat.host":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
			case "machineStat.host.hostIP":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.MachineStat.Host.HostIP = vals[0]
			case "machineStat.host.hostname":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.MachineStat.Host.Hostname = vals[0]
			case "machineStat.host.uptimeSec":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Host.UptimeSec = val
			case "machineStat.host.bootTimeSec":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Host.BootTimeSec = val
			case "machineStat.host.OS":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.MachineStat.Host.OS = vals[0]
			case "machineStat.host.platform":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.MachineStat.Host.Platform = vals[0]
			case "machineStat.host.platformVersion":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.MachineStat.Host.PlatformVersion = vals[0]
			case "machineStat.host.kernelVersion":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.MachineStat.Host.KernelVersion = vals[0]
			case "machineStat.host.kernelArch":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Host == nil {
					m.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.MachineStat.Host.KernelArch = vals[0]
			case "machineStat.pod":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Pod == nil {
					m.MachineStat.Pod = &PipelineTaskMachinePodStat{}
				}
			case "machineStat.pod.podIP":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Pod == nil {
					m.MachineStat.Pod = &PipelineTaskMachinePodStat{}
				}
				m.MachineStat.Pod.PodIP = vals[0]
			case "machineStat.load":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Load == nil {
					m.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
			case "machineStat.load.load1":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Load == nil {
					m.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.MachineStat.Load.Load1 = val
			case "machineStat.load.load5":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Load == nil {
					m.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.MachineStat.Load.Load5 = val
			case "machineStat.load.load15":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Load == nil {
					m.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.MachineStat.Load.Load15 = val
			case "machineStat.mem":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Mem == nil {
					m.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
			case "machineStat.mem.total":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Mem == nil {
					m.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Mem.Total = val
			case "machineStat.mem.available":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Mem == nil {
					m.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Mem.Available = val
			case "machineStat.mem.used":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Mem == nil {
					m.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Mem.Used = val
			case "machineStat.mem.free":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Mem == nil {
					m.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Mem.Free = val
			case "machineStat.mem.usedPercent":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Mem == nil {
					m.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.MachineStat.Mem.UsedPercent = val
			case "machineStat.mem.buffers":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Mem == nil {
					m.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Mem.Buffers = val
			case "machineStat.mem.cached":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Mem == nil {
					m.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Mem.Cached = val
			case "machineStat.swap":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Swap == nil {
					m.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
			case "machineStat.swap.total":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Swap == nil {
					m.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Swap.Total = val
			case "machineStat.swap.used":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Swap == nil {
					m.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Swap.Used = val
			case "machineStat.swap.free":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Swap == nil {
					m.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.MachineStat.Swap.Free = val
			case "machineStat.swap.usedPercent":
				if m.MachineStat == nil {
					m.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.MachineStat.Swap == nil {
					m.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.MachineStat.Swap.UsedPercent = val
			}
		}
	}
	return nil
}

// PipelineTaskSnippetDetail implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskSnippetDetail) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "directSnippetTaskNum":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.DirectSnippetTaskNum = val
			case "recursiveSnippetTaskNum":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.RecursiveSnippetTaskNum = val
			}
		}
	}
	return nil
}

// PipelineTaskMachineStat implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskMachineStat) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "host":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
			case "host.hostIP":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				m.Host.HostIP = vals[0]
			case "host.hostname":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				m.Host.Hostname = vals[0]
			case "host.uptimeSec":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Host.UptimeSec = val
			case "host.bootTimeSec":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Host.BootTimeSec = val
			case "host.OS":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				m.Host.OS = vals[0]
			case "host.platform":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				m.Host.Platform = vals[0]
			case "host.platformVersion":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				m.Host.PlatformVersion = vals[0]
			case "host.kernelVersion":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				m.Host.KernelVersion = vals[0]
			case "host.kernelArch":
				if m.Host == nil {
					m.Host = &PipelineTaskMachineHostStat{}
				}
				m.Host.KernelArch = vals[0]
			case "pod":
				if m.Pod == nil {
					m.Pod = &PipelineTaskMachinePodStat{}
				}
			case "pod.podIP":
				if m.Pod == nil {
					m.Pod = &PipelineTaskMachinePodStat{}
				}
				m.Pod.PodIP = vals[0]
			case "load":
				if m.Load == nil {
					m.Load = &PipelineTaskMachineLoadStat{}
				}
			case "load.load1":
				if m.Load == nil {
					m.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Load.Load1 = val
			case "load.load5":
				if m.Load == nil {
					m.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Load.Load5 = val
			case "load.load15":
				if m.Load == nil {
					m.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Load.Load15 = val
			case "mem":
				if m.Mem == nil {
					m.Mem = &PipelineTaskMachineMemStat{}
				}
			case "mem.total":
				if m.Mem == nil {
					m.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Mem.Total = val
			case "mem.available":
				if m.Mem == nil {
					m.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Mem.Available = val
			case "mem.used":
				if m.Mem == nil {
					m.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Mem.Used = val
			case "mem.free":
				if m.Mem == nil {
					m.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Mem.Free = val
			case "mem.usedPercent":
				if m.Mem == nil {
					m.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Mem.UsedPercent = val
			case "mem.buffers":
				if m.Mem == nil {
					m.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Mem.Buffers = val
			case "mem.cached":
				if m.Mem == nil {
					m.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Mem.Cached = val
			case "swap":
				if m.Swap == nil {
					m.Swap = &PipelineTaskMachineSwapStat{}
				}
			case "swap.total":
				if m.Swap == nil {
					m.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Swap.Total = val
			case "swap.used":
				if m.Swap == nil {
					m.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Swap.Used = val
			case "swap.free":
				if m.Swap == nil {
					m.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Swap.Free = val
			case "swap.usedPercent":
				if m.Swap == nil {
					m.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Swap.UsedPercent = val
			}
		}
	}
	return nil
}

// PipelineTaskMachineHostStat implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskMachineHostStat) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "hostIP":
				m.HostIP = vals[0]
			case "hostname":
				m.Hostname = vals[0]
			case "uptimeSec":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.UptimeSec = val
			case "bootTimeSec":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.BootTimeSec = val
			case "OS":
				m.OS = vals[0]
			case "platform":
				m.Platform = vals[0]
			case "platformVersion":
				m.PlatformVersion = vals[0]
			case "kernelVersion":
				m.KernelVersion = vals[0]
			case "kernelArch":
				m.KernelArch = vals[0]
			}
		}
	}
	return nil
}

// PipelineTaskMachinePodStat implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskMachinePodStat) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "podIP":
				m.PodIP = vals[0]
			}
		}
	}
	return nil
}

// PipelineTaskMachineLoadStat implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskMachineLoadStat) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "load1":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Load1 = val
			case "load5":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Load5 = val
			case "load15":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Load15 = val
			}
		}
	}
	return nil
}

// PipelineTaskMachineMemStat implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskMachineMemStat) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "total":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Total = val
			case "available":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Available = val
			case "used":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Used = val
			case "free":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Free = val
			case "usedPercent":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.UsedPercent = val
			case "buffers":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Buffers = val
			case "cached":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Cached = val
			}
		}
	}
	return nil
}

// PipelineTaskMachineSwapStat implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskMachineSwapStat) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "total":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Total = val
			case "used":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Used = val
			case "free":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Free = val
			case "usedPercent":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.UsedPercent = val
			}
		}
	}
	return nil
}

// PipelineTaskActionDetail implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskActionDetail) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "logoUrl":
				m.LogoUrl = vals[0]
			case "displayName":
				m.DisplayName = vals[0]
			case "description":
				m.Description = vals[0]
			}
		}
	}
	return nil
}

// PipelineCreateRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineCreateRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineYml":
				m.PipelineYml = vals[0]
			case "clusterName":
				m.ClusterName = vals[0]
			case "pipelineYmlName":
				m.PipelineYmlName = vals[0]
			case "pipelineSource":
				m.PipelineSource = vals[0]
			case "configManageNamespaces":
				m.ConfigManageNamespaces = vals
			case "autoRun":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AutoRun = val
			case "forceRun":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.ForceRun = val
			case "autoRunAtOnce":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AutoRunAtOnce = val
			case "autoStartCron":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AutoStartCron = val
			case "cronStartFrom":
				if m.CronStartFrom == nil {
					m.CronStartFrom = &timestamppb.Timestamp{}
				}
			case "cronStartFrom.seconds":
				if m.CronStartFrom == nil {
					m.CronStartFrom = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CronStartFrom.Seconds = val
			case "cronStartFrom.nanos":
				if m.CronStartFrom == nil {
					m.CronStartFrom = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.CronStartFrom.Nanos = int32(val)
			case "GC":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
			case "GC.resourceGC":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.ResourceGC == nil {
					m.GC.ResourceGC = &PipelineResourceGC{}
				}
			case "GC.resourceGC.successTTLSecond":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.ResourceGC == nil {
					m.GC.ResourceGC = &PipelineResourceGC{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.GC.ResourceGC.SuccessTTLSecond = val
			case "GC.resourceGC.failedTTLSecond":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.ResourceGC == nil {
					m.GC.ResourceGC = &PipelineResourceGC{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.GC.ResourceGC.FailedTTLSecond = val
			case "GC.databaseGC":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.DatabaseGC == nil {
					m.GC.DatabaseGC = &PipelineDatabaseGC{}
				}
			case "GC.databaseGC.analyzed":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.DatabaseGC == nil {
					m.GC.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.GC.DatabaseGC.Analyzed == nil {
					m.GC.DatabaseGC.Analyzed = &PipelineDBGCItem{}
				}
			case "GC.databaseGC.analyzed.needArchive":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.DatabaseGC == nil {
					m.GC.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.GC.DatabaseGC.Analyzed == nil {
					m.GC.DatabaseGC.Analyzed = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.GC.DatabaseGC.Analyzed.NeedArchive = val
			case "GC.databaseGC.analyzed.TTLSecond":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.DatabaseGC == nil {
					m.GC.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.GC.DatabaseGC.Analyzed == nil {
					m.GC.DatabaseGC.Analyzed = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.GC.DatabaseGC.Analyzed.TTLSecond = val
			case "GC.databaseGC.finished":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.DatabaseGC == nil {
					m.GC.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.GC.DatabaseGC.Finished == nil {
					m.GC.DatabaseGC.Finished = &PipelineDBGCItem{}
				}
			case "GC.databaseGC.finished.needArchive":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.DatabaseGC == nil {
					m.GC.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.GC.DatabaseGC.Finished == nil {
					m.GC.DatabaseGC.Finished = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.GC.DatabaseGC.Finished.NeedArchive = val
			case "GC.databaseGC.finished.TTLSecond":
				if m.GC == nil {
					m.GC = &PipelineGC{}
				}
				if m.GC.DatabaseGC == nil {
					m.GC.DatabaseGC = &PipelineDatabaseGC{}
				}
				if m.GC.DatabaseGC.Finished == nil {
					m.GC.DatabaseGC.Finished = &PipelineDBGCItem{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.GC.DatabaseGC.Finished.TTLSecond = val
			case "bindQueue":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
			case "bindQueue.ID":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.BindQueue.ID = val
			case "bindQueue.name":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				m.BindQueue.Name = vals[0]
			case "bindQueue.pipelineSource":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				m.BindQueue.PipelineSource = vals[0]
			case "bindQueue.clusterName":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				m.BindQueue.ClusterName = vals[0]
			case "bindQueue.scheduleStrategy":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				m.BindQueue.ScheduleStrategy = vals[0]
			case "bindQueue.mode":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				m.BindQueue.Mode = vals[0]
			case "bindQueue.priority":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.BindQueue.Priority = val
			case "bindQueue.concurrency":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.BindQueue.Concurrency = val
			case "bindQueue.maxCPU":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.BindQueue.MaxCPU = val
			case "bindQueue.maxMemoryMB":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.BindQueue.MaxMemoryMB = val
			case "bindQueue.timeCreated":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.TimeCreated == nil {
					m.BindQueue.TimeCreated = &timestamppb.Timestamp{}
				}
			case "bindQueue.timeCreated.seconds":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.TimeCreated == nil {
					m.BindQueue.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.BindQueue.TimeCreated.Seconds = val
			case "bindQueue.timeCreated.nanos":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.TimeCreated == nil {
					m.BindQueue.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.BindQueue.TimeCreated.Nanos = int32(val)
			case "bindQueue.timeUpdated":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.TimeUpdated == nil {
					m.BindQueue.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "bindQueue.timeUpdated.seconds":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.TimeUpdated == nil {
					m.BindQueue.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.BindQueue.TimeUpdated.Seconds = val
			case "bindQueue.timeUpdated.nanos":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.TimeUpdated == nil {
					m.BindQueue.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.BindQueue.TimeUpdated.Nanos = int32(val)
			case "bindQueue.usage":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.Usage == nil {
					m.BindQueue.Usage = &pb2.QueueUsage{}
				}
			case "bindQueue.usage.inUseCPU":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.Usage == nil {
					m.BindQueue.Usage = &pb2.QueueUsage{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.BindQueue.Usage.InUseCPU = val
			case "bindQueue.usage.inUseMemoryMB":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.Usage == nil {
					m.BindQueue.Usage = &pb2.QueueUsage{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.BindQueue.Usage.InUseMemoryMB = val
			case "bindQueue.usage.remainingCPU":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.Usage == nil {
					m.BindQueue.Usage = &pb2.QueueUsage{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.BindQueue.Usage.RemainingCPU = val
			case "bindQueue.usage.remainingMemoryMB":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.Usage == nil {
					m.BindQueue.Usage = &pb2.QueueUsage{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.BindQueue.Usage.RemainingMemoryMB = val
			case "bindQueue.usage.processingCount":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.Usage == nil {
					m.BindQueue.Usage = &pb2.QueueUsage{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.BindQueue.Usage.ProcessingCount = val
			case "bindQueue.usage.pendingCount":
				if m.BindQueue == nil {
					m.BindQueue = &pb2.Queue{}
				}
				if m.BindQueue.Usage == nil {
					m.BindQueue.Usage = &pb2.QueueUsage{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.BindQueue.Usage.PendingCount = val
			case "identityInfo":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
			case "identityInfo.userID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.UserID = vals[0]
			case "identityInfo.internalClient":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.InternalClient = vals[0]
			case "identityInfo.orgID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.OrgID = vals[0]
			}
		}
	}
	return nil
}

// PipelineCreateResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineCreateResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "data":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
			case "data.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ID = val
			case "data.source":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Source = vals[0]
			case "data.ymlName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlName = vals[0]
			case "data.namespace":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Namespace = vals[0]
			case "data.clusterName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ClusterName = vals[0]
			case "data.status":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Status = vals[0]
			case "data.type":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Type = vals[0]
			case "data.triggerMode":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.TriggerMode = vals[0]
			case "data.cronID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CronID = val
			case "data.ymlSource":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlSource = vals[0]
			case "data.ymlContent":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlContent = vals[0]
			case "data.extra":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
			case "data.extra.diceWorkspace":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.DiceWorkspace = vals[0]
			case "data.extra.submitUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
			case "data.extra.submitUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.ID = vals[0]
			case "data.extra.submitUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.Name = vals[0]
			case "data.extra.submitUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.Avatar = vals[0]
			case "data.extra.runUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
			case "data.extra.runUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.ID = vals[0]
			case "data.extra.runUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.Name = vals[0]
			case "data.extra.runUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.Avatar = vals[0]
			case "data.extra.cancelUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
			case "data.extra.cancelUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.ID = vals[0]
			case "data.extra.cancelUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.Name = vals[0]
			case "data.extra.cancelUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.Avatar = vals[0]
			case "data.extra.cronExpr":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.CronExpr = vals[0]
			case "data.extra.cronTriggerTime":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
			case "data.extra.cronTriggerTime.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Extra.CronTriggerTime.Seconds = val
			case "data.extra.cronTriggerTime.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.Extra.CronTriggerTime.Nanos = int32(val)
			case "data.extra.show_message":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
			case "data.extra.show_message.msg":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				m.Data.Extra.ShowMessage.Msg = vals[0]
			case "data.extra.show_message.stacks":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				m.Data.Extra.ShowMessage.Stacks = vals
			case "data.extra.show_message.abortRun":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.ShowMessage.AbortRun = val
			case "data.extra.configManageNamespaces":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.ConfigManageNamespaces = vals
			case "data.extra.isAutoRun":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.IsAutoRun = val
			case "data.extra.callbackURLs":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.CallbackURLs = vals
			case "data.orgID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.OrgID = val
			case "data.orgName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.OrgName = vals[0]
			case "data.projectID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ProjectID = val
			case "data.projectName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ProjectName = vals[0]
			case "data.applicationID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ApplicationID = val
			case "data.applicationName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ApplicationName = vals[0]
			case "data.branch":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Branch = vals[0]
			case "data.commit":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Commit = vals[0]
			case "data.commitDetail":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
			case "data.commitDetail.commitID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.CommitID = vals[0]
			case "data.commitDetail.repo":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Repo = vals[0]
			case "data.commitDetail.repoAbbr":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.RepoAbbr = vals[0]
			case "data.commitDetail.author":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Author = vals[0]
			case "data.commitDetail.email":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Email = vals[0]
			case "data.commitDetail.time":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
			case "data.commitDetail.time.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CommitDetail.Time.Seconds = val
			case "data.commitDetail.time.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.CommitDetail.Time.Nanos = int32(val)
			case "data.commitDetail.comment":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Comment = vals[0]
			case "data.progress":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Progress = val
			case "data.costTimeSec":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CostTimeSec = val
			case "data.timeBegin":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
			case "data.timeBegin.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Seconds = val
			case "data.timeBegin.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Nanos = int32(val)
			case "data.timeEnd":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
			case "data.timeEnd.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Seconds = val
			case "data.timeEnd.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Nanos = int32(val)
			case "data.timeCreated":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
			case "data.timeCreated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Seconds = val
			case "data.timeCreated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Nanos = int32(val)
			case "data.timeUpdated":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "data.timeUpdated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Seconds = val
			case "data.timeUpdated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelinePagingRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelinePagingRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pageNum":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PageNum = val
			case "pageSize":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PageSize = val
			case "largePageSize":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.LargePageSize = val
			case "countOnly":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.CountOnly = val
			case "allSources":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AllSources = val
			case "sources":
				m.Sources = vals
			case "ymlNames":
				m.YmlNames = vals
			case "statuses":
				m.Statuses = vals
			case "notStatuses":
				m.NotStatuses = vals
			case "triggerModes":
				m.TriggerModes = vals
			case "clusterNames":
				m.ClusterNames = vals
			case "includeSnippet":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.IncludeSnippet = val
			case "startTimeBeginTimestamp":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.StartTimeBeginTimestamp = val
			case "startTimeBeginCST":
				m.StartTimeBeginCST = vals[0]
			case "endTimeBeginTimestamp":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.EndTimeBeginTimestamp = val
			case "endTimeBeginCST":
				m.EndTimeBeginCST = vals[0]
			case "startTimeCreatedTimestamp":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.StartTimeCreatedTimestamp = val
			case "endTimeCreatedTimestamp":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.EndTimeCreatedTimestamp = val
			case "mustMatchLabelsJSON":
				m.MustMatchLabelsJSON = vals[0]
			case "mustMatchLabelsQueryParams":
				m.MustMatchLabelsQueryParams = vals
			case "anyMatchLabelsJSON":
				m.AnyMatchLabelsJSON = vals[0]
			case "anyMatchLabelsQueryParams":
				m.AnyMatchLabelsQueryParams = vals
			case "commaBranches":
				m.CommaBranches = vals[0]
			case "commaSources":
				m.CommaSources = vals[0]
			case "commaYmlNames":
				m.CommaYmlNames = vals[0]
			case "commaStatuses":
				m.CommaStatuses = vals[0]
			case "appID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.AppID = val
			case "branches":
				m.Branches = vals
			}
		}
	}
	return nil
}

// PipelinePagingResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelinePagingResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "data":
				if m.Data == nil {
					m.Data = &PipelineListResponseData{}
				}
			case "data.total":
				if m.Data == nil {
					m.Data = &PipelineListResponseData{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Total = val
			case "data.currentPageSize":
				if m.Data == nil {
					m.Data = &PipelineListResponseData{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CurrentPageSize = val
			}
		}
	}
	return nil
}

// PipelineListResponseData implement urlenc.URLValuesUnmarshaler.
func (m *PipelineListResponseData) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "total":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Total = val
			case "currentPageSize":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CurrentPageSize = val
			}
		}
	}
	return nil
}

// PagePipeline implement urlenc.URLValuesUnmarshaler.
func (m *PagePipeline) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "ID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ID = val
			case "cronID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CronID = val
			case "commit":
				m.Commit = vals[0]
			case "source":
				m.Source = vals[0]
			case "ymlName":
				m.YmlName = vals[0]
			case "extra":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
			case "extra.diceWorkspace":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.DiceWorkspace = vals[0]
			case "extra.submitUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
			case "extra.submitUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.ID = vals[0]
			case "extra.submitUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.Name = vals[0]
			case "extra.submitUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.SubmitUser == nil {
					m.Extra.SubmitUser = &PipelineUser{}
				}
				m.Extra.SubmitUser.Avatar = vals[0]
			case "extra.runUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
			case "extra.runUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.ID = vals[0]
			case "extra.runUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.Name = vals[0]
			case "extra.runUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.RunUser == nil {
					m.Extra.RunUser = &PipelineUser{}
				}
				m.Extra.RunUser.Avatar = vals[0]
			case "extra.cancelUser":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
			case "extra.cancelUser.ID":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.ID = vals[0]
			case "extra.cancelUser.name":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.Name = vals[0]
			case "extra.cancelUser.avatar":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CancelUser == nil {
					m.Extra.CancelUser = &PipelineUser{}
				}
				m.Extra.CancelUser.Avatar = vals[0]
			case "extra.cronExpr":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.CronExpr = vals[0]
			case "extra.cronTriggerTime":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
			case "extra.cronTriggerTime.seconds":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Extra.CronTriggerTime.Seconds = val
			case "extra.cronTriggerTime.nanos":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.CronTriggerTime == nil {
					m.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Extra.CronTriggerTime.Nanos = int32(val)
			case "extra.show_message":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
			case "extra.show_message.msg":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				m.Extra.ShowMessage.Msg = vals[0]
			case "extra.show_message.stacks":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				m.Extra.ShowMessage.Stacks = vals
			case "extra.show_message.abortRun":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				if m.Extra.ShowMessage == nil {
					m.Extra.ShowMessage = &ShowMessage{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Extra.ShowMessage.AbortRun = val
			case "extra.configManageNamespaces":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.ConfigManageNamespaces = vals
			case "extra.isAutoRun":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Extra.IsAutoRun = val
			case "extra.callbackURLs":
				if m.Extra == nil {
					m.Extra = &PipelineExtra{}
				}
				m.Extra.CallbackURLs = vals
			case "type":
				m.Type = vals[0]
			case "triggerMode":
				m.TriggerMode = vals[0]
			case "clusterName":
				m.ClusterName = vals[0]
			case "status":
				m.Status = vals[0]
			case "progress":
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Progress = val
			case "isSnippet":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.IsSnippet = val
			case "parentPipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ParentPipelineID = val
			case "parentTaskID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.ParentTaskID = val
			case "costTimeSec":
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.CostTimeSec = val
			case "timeBegin":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
			case "timeBegin.seconds":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeBegin.Seconds = val
			case "timeBegin.nanos":
				if m.TimeBegin == nil {
					m.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeBegin.Nanos = int32(val)
			case "timeEnd":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
			case "timeEnd.seconds":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeEnd.Seconds = val
			case "timeEnd.nanos":
				if m.TimeEnd == nil {
					m.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeEnd.Nanos = int32(val)
			case "timeCreated":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
			case "timeCreated.seconds":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeCreated.Seconds = val
			case "timeCreated.nanos":
				if m.TimeCreated == nil {
					m.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeCreated.Nanos = int32(val)
			case "timeUpdated":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "timeUpdated.seconds":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TimeUpdated.Seconds = val
			case "timeUpdated.nanos":
				if m.TimeUpdated == nil {
					m.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// SnippetConfig implement urlenc.URLValuesUnmarshaler.
func (m *SnippetConfig) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "source":
				m.Source = vals[0]
			case "name":
				m.Name = vals[0]
			}
		}
	}
	return nil
}

// PipelineDetailRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineDetailRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "simplePipelineBaseResult":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.SimplePipelineBaseResult = val
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			}
		}
	}
	return nil
}

// PipelineDetailResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineDetailResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "data":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
			case "data.ID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ID = val
			case "data.source":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.Source = vals[0]
			case "data.ymlName":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.YmlName = vals[0]
			case "data.namespace":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.Namespace = vals[0]
			case "data.clusterName":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.ClusterName = vals[0]
			case "data.status":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.Status = vals[0]
			case "data.type":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.Type = vals[0]
			case "data.triggerMode":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.TriggerMode = vals[0]
			case "data.cronID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CronID = val
			case "data.ymlSource":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.YmlSource = vals[0]
			case "data.ymlContent":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.YmlContent = vals[0]
			case "data.extra":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
			case "data.extra.diceWorkspace":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.DiceWorkspace = vals[0]
			case "data.extra.submitUser":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
			case "data.extra.submitUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.ID = vals[0]
			case "data.extra.submitUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.Name = vals[0]
			case "data.extra.submitUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.Avatar = vals[0]
			case "data.extra.runUser":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
			case "data.extra.runUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.ID = vals[0]
			case "data.extra.runUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.Name = vals[0]
			case "data.extra.runUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.Avatar = vals[0]
			case "data.extra.cancelUser":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
			case "data.extra.cancelUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.ID = vals[0]
			case "data.extra.cancelUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.Name = vals[0]
			case "data.extra.cancelUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.Avatar = vals[0]
			case "data.extra.cronExpr":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.CronExpr = vals[0]
			case "data.extra.cronTriggerTime":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
			case "data.extra.cronTriggerTime.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Extra.CronTriggerTime.Seconds = val
			case "data.extra.cronTriggerTime.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.Extra.CronTriggerTime.Nanos = int32(val)
			case "data.extra.show_message":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
			case "data.extra.show_message.msg":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				m.Data.Extra.ShowMessage.Msg = vals[0]
			case "data.extra.show_message.stacks":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				m.Data.Extra.ShowMessage.Stacks = vals
			case "data.extra.show_message.abortRun":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.ShowMessage.AbortRun = val
			case "data.extra.configManageNamespaces":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.ConfigManageNamespaces = vals
			case "data.extra.isAutoRun":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.IsAutoRun = val
			case "data.extra.callbackURLs":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.CallbackURLs = vals
			case "data.orgID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.OrgID = val
			case "data.orgName":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.OrgName = vals[0]
			case "data.projectID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ProjectID = val
			case "data.projectName":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.ProjectName = vals[0]
			case "data.applicationID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ApplicationID = val
			case "data.applicationName":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.ApplicationName = vals[0]
			case "data.branch":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.Branch = vals[0]
			case "data.commit":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				m.Data.Commit = vals[0]
			case "data.commitDetail":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
			case "data.commitDetail.commitID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.CommitID = vals[0]
			case "data.commitDetail.repo":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Repo = vals[0]
			case "data.commitDetail.repoAbbr":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.RepoAbbr = vals[0]
			case "data.commitDetail.author":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Author = vals[0]
			case "data.commitDetail.email":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Email = vals[0]
			case "data.commitDetail.time":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
			case "data.commitDetail.time.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CommitDetail.Time.Seconds = val
			case "data.commitDetail.time.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.CommitDetail.Time.Nanos = int32(val)
			case "data.commitDetail.comment":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Comment = vals[0]
			case "data.progress":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Progress = val
			case "data.costTimeSec":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CostTimeSec = val
			case "data.timeBegin":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
			case "data.timeBegin.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Seconds = val
			case "data.timeBegin.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Nanos = int32(val)
			case "data.timeEnd":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
			case "data.timeEnd.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Seconds = val
			case "data.timeEnd.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Nanos = int32(val)
			case "data.timeCreated":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
			case "data.timeCreated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Seconds = val
			case "data.timeCreated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Nanos = int32(val)
			case "data.timeUpdated":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "data.timeUpdated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Seconds = val
			case "data.timeUpdated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Nanos = int32(val)
			case "data.pipelineCron":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
			case "data.pipelineCron.ID":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.PipelineCron.ID = val
			case "data.pipelineCron.timeCreated":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.TimeCreated == nil {
					m.Data.PipelineCron.TimeCreated = &timestamppb.Timestamp{}
				}
			case "data.pipelineCron.timeCreated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.TimeCreated == nil {
					m.Data.PipelineCron.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.PipelineCron.TimeCreated.Seconds = val
			case "data.pipelineCron.timeCreated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.TimeCreated == nil {
					m.Data.PipelineCron.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.PipelineCron.TimeCreated.Nanos = int32(val)
			case "data.pipelineCron.timeUpdated":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.TimeUpdated == nil {
					m.Data.PipelineCron.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "data.pipelineCron.timeUpdated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.TimeUpdated == nil {
					m.Data.PipelineCron.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.PipelineCron.TimeUpdated.Seconds = val
			case "data.pipelineCron.timeUpdated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.TimeUpdated == nil {
					m.Data.PipelineCron.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.PipelineCron.TimeUpdated.Nanos = int32(val)
			case "data.pipelineCron.cronExpr":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				m.Data.PipelineCron.CronExpr = vals[0]
			case "data.pipelineCron.cronStartTime":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.CronStartTime == nil {
					m.Data.PipelineCron.CronStartTime = &timestamppb.Timestamp{}
				}
			case "data.pipelineCron.cronStartTime.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.CronStartTime == nil {
					m.Data.PipelineCron.CronStartTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.PipelineCron.CronStartTime.Seconds = val
			case "data.pipelineCron.cronStartTime.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				if m.Data.PipelineCron.CronStartTime == nil {
					m.Data.PipelineCron.CronStartTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.PipelineCron.CronStartTime.Nanos = int32(val)
			case "data.pipelineCron.pipelineYmlName":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				m.Data.PipelineCron.PipelineYmlName = vals[0]
			case "data.pipelineCron.enable":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineCron == nil {
					m.Data.PipelineCron = &pb1.Cron{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineCron.Enable = val
			case "data.pipelineButton":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
			case "data.pipelineButton.canManualRun":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanManualRun = val
			case "data.pipelineButton.canCancel":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanCancel = val
			case "data.pipelineButton.canForceCancel":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanForceCancel = val
			case "data.pipelineButton.canRerun":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanRerun = val
			case "data.pipelineButton.canRerunFailed":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanRerunFailed = val
			case "data.pipelineButton.canStartCron":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanStartCron = val
			case "data.pipelineButton.canStopCron":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanStopCron = val
			case "data.pipelineButton.canPause":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanPause = val
			case "data.pipelineButton.canUnpause":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanUnpause = val
			case "data.pipelineButton.canDelete":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				if m.Data.PipelineButton == nil {
					m.Data.PipelineButton = &PipelineButton{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.PipelineButton.CanDelete = val
			case "data.needApproval":
				if m.Data == nil {
					m.Data = &PipelineInstanceDetail{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.NeedApproval = val
			}
		}
	}
	return nil
}

// PipelineTaskOperateRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskOperateRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "taskID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TaskID = val
			case "disable":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Disable = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Disable = val
					} else {
						m.Disable = structpb.NewStringValue(vals[0])
					}
				}
			case "pause":
				if len(vals) > 1 {
					var list []interface{}
					for _, text := range vals {
						var v interface{}
						err := json.NewDecoder(strings.NewReader(text)).Decode(&v)
						if err != nil {
							list = append(list, v)
						} else {
							list = append(list, text)
						}
					}
					val, _ := structpb.NewList(list)
					m.Pause = structpb.NewListValue(val)
				} else {
					var v interface{}
					err := json.NewDecoder(strings.NewReader(vals[0])).Decode(&v)
					if err != nil {
						val, _ := structpb.NewValue(v)
						m.Pause = val
					} else {
						m.Pause = structpb.NewStringValue(vals[0])
					}
				}
			}
		}
	}
	return nil
}

// PipelineOperateRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineOperateRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			}
		}
	}
	return nil
}

// PipelineOperateResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineOperateResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	return nil
}

// PipelineDeleteRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineDeleteRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			}
		}
	}
	return nil
}

// PipelineDeleteResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineDeleteResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	return nil
}

// PipelineRunRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineRunRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "forceRun":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.ForceRun = val
			case "identityInfo":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
			case "identityInfo.userID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.UserID = vals[0]
			case "identityInfo.internalClient":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.InternalClient = vals[0]
			case "identityInfo.orgID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.OrgID = vals[0]
			}
		}
	}
	return nil
}

// PipelineRunResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineRunResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	return nil
}

// PipelineCancelRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineCancelRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "identityInfo":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
			case "identityInfo.userID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.UserID = vals[0]
			case "identityInfo.internalClient":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.InternalClient = vals[0]
			case "identityInfo.orgID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.OrgID = vals[0]
			}
		}
	}
	return nil
}

// PipelineCancelResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineCancelResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	return nil
}

// PipelineRerunRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineRerunRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "autoRunAtOnce":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AutoRunAtOnce = val
			case "identityInfo":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
			case "identityInfo.userID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.UserID = vals[0]
			case "identityInfo.internalClient":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.InternalClient = vals[0]
			case "identityInfo.orgID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.OrgID = vals[0]
			}
		}
	}
	return nil
}

// PipelineRerunResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineRerunResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "data":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
			case "data.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ID = val
			case "data.source":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Source = vals[0]
			case "data.ymlName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlName = vals[0]
			case "data.namespace":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Namespace = vals[0]
			case "data.clusterName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ClusterName = vals[0]
			case "data.status":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Status = vals[0]
			case "data.type":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Type = vals[0]
			case "data.triggerMode":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.TriggerMode = vals[0]
			case "data.cronID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CronID = val
			case "data.ymlSource":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlSource = vals[0]
			case "data.ymlContent":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlContent = vals[0]
			case "data.extra":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
			case "data.extra.diceWorkspace":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.DiceWorkspace = vals[0]
			case "data.extra.submitUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
			case "data.extra.submitUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.ID = vals[0]
			case "data.extra.submitUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.Name = vals[0]
			case "data.extra.submitUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.Avatar = vals[0]
			case "data.extra.runUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
			case "data.extra.runUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.ID = vals[0]
			case "data.extra.runUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.Name = vals[0]
			case "data.extra.runUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.Avatar = vals[0]
			case "data.extra.cancelUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
			case "data.extra.cancelUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.ID = vals[0]
			case "data.extra.cancelUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.Name = vals[0]
			case "data.extra.cancelUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.Avatar = vals[0]
			case "data.extra.cronExpr":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.CronExpr = vals[0]
			case "data.extra.cronTriggerTime":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
			case "data.extra.cronTriggerTime.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Extra.CronTriggerTime.Seconds = val
			case "data.extra.cronTriggerTime.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.Extra.CronTriggerTime.Nanos = int32(val)
			case "data.extra.show_message":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
			case "data.extra.show_message.msg":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				m.Data.Extra.ShowMessage.Msg = vals[0]
			case "data.extra.show_message.stacks":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				m.Data.Extra.ShowMessage.Stacks = vals
			case "data.extra.show_message.abortRun":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.ShowMessage.AbortRun = val
			case "data.extra.configManageNamespaces":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.ConfigManageNamespaces = vals
			case "data.extra.isAutoRun":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.IsAutoRun = val
			case "data.extra.callbackURLs":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.CallbackURLs = vals
			case "data.orgID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.OrgID = val
			case "data.orgName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.OrgName = vals[0]
			case "data.projectID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ProjectID = val
			case "data.projectName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ProjectName = vals[0]
			case "data.applicationID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ApplicationID = val
			case "data.applicationName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ApplicationName = vals[0]
			case "data.branch":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Branch = vals[0]
			case "data.commit":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Commit = vals[0]
			case "data.commitDetail":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
			case "data.commitDetail.commitID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.CommitID = vals[0]
			case "data.commitDetail.repo":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Repo = vals[0]
			case "data.commitDetail.repoAbbr":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.RepoAbbr = vals[0]
			case "data.commitDetail.author":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Author = vals[0]
			case "data.commitDetail.email":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Email = vals[0]
			case "data.commitDetail.time":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
			case "data.commitDetail.time.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CommitDetail.Time.Seconds = val
			case "data.commitDetail.time.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.CommitDetail.Time.Nanos = int32(val)
			case "data.commitDetail.comment":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Comment = vals[0]
			case "data.progress":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Progress = val
			case "data.costTimeSec":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CostTimeSec = val
			case "data.timeBegin":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
			case "data.timeBegin.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Seconds = val
			case "data.timeBegin.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Nanos = int32(val)
			case "data.timeEnd":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
			case "data.timeEnd.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Seconds = val
			case "data.timeEnd.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Nanos = int32(val)
			case "data.timeCreated":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
			case "data.timeCreated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Seconds = val
			case "data.timeCreated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Nanos = int32(val)
			case "data.timeUpdated":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "data.timeUpdated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Seconds = val
			case "data.timeUpdated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelineRerunFailedRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineRerunFailedRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "autoRunAtOnce":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AutoRunAtOnce = val
			case "identityInfo":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
			case "identityInfo.userID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.UserID = vals[0]
			case "identityInfo.internalClient":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.InternalClient = vals[0]
			case "identityInfo.orgID":
				if m.IdentityInfo == nil {
					m.IdentityInfo = &pb.IdentityInfo{}
				}
				m.IdentityInfo.OrgID = vals[0]
			}
		}
	}
	return nil
}

// PipelineRerunFailedResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineRerunFailedResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "data":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
			case "data.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ID = val
			case "data.source":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Source = vals[0]
			case "data.ymlName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlName = vals[0]
			case "data.namespace":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Namespace = vals[0]
			case "data.clusterName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ClusterName = vals[0]
			case "data.status":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Status = vals[0]
			case "data.type":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Type = vals[0]
			case "data.triggerMode":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.TriggerMode = vals[0]
			case "data.cronID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CronID = val
			case "data.ymlSource":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlSource = vals[0]
			case "data.ymlContent":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.YmlContent = vals[0]
			case "data.extra":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
			case "data.extra.diceWorkspace":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.DiceWorkspace = vals[0]
			case "data.extra.submitUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
			case "data.extra.submitUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.ID = vals[0]
			case "data.extra.submitUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.Name = vals[0]
			case "data.extra.submitUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.SubmitUser == nil {
					m.Data.Extra.SubmitUser = &PipelineUser{}
				}
				m.Data.Extra.SubmitUser.Avatar = vals[0]
			case "data.extra.runUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
			case "data.extra.runUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.ID = vals[0]
			case "data.extra.runUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.Name = vals[0]
			case "data.extra.runUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.RunUser == nil {
					m.Data.Extra.RunUser = &PipelineUser{}
				}
				m.Data.Extra.RunUser.Avatar = vals[0]
			case "data.extra.cancelUser":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
			case "data.extra.cancelUser.ID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.ID = vals[0]
			case "data.extra.cancelUser.name":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.Name = vals[0]
			case "data.extra.cancelUser.avatar":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CancelUser == nil {
					m.Data.Extra.CancelUser = &PipelineUser{}
				}
				m.Data.Extra.CancelUser.Avatar = vals[0]
			case "data.extra.cronExpr":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.CronExpr = vals[0]
			case "data.extra.cronTriggerTime":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
			case "data.extra.cronTriggerTime.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Extra.CronTriggerTime.Seconds = val
			case "data.extra.cronTriggerTime.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.CronTriggerTime == nil {
					m.Data.Extra.CronTriggerTime = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.Extra.CronTriggerTime.Nanos = int32(val)
			case "data.extra.show_message":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
			case "data.extra.show_message.msg":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				m.Data.Extra.ShowMessage.Msg = vals[0]
			case "data.extra.show_message.stacks":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				m.Data.Extra.ShowMessage.Stacks = vals
			case "data.extra.show_message.abortRun":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				if m.Data.Extra.ShowMessage == nil {
					m.Data.Extra.ShowMessage = &ShowMessage{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.ShowMessage.AbortRun = val
			case "data.extra.configManageNamespaces":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.ConfigManageNamespaces = vals
			case "data.extra.isAutoRun":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.IsAutoRun = val
			case "data.extra.callbackURLs":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineExtra{}
				}
				m.Data.Extra.CallbackURLs = vals
			case "data.orgID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.OrgID = val
			case "data.orgName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.OrgName = vals[0]
			case "data.projectID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ProjectID = val
			case "data.projectName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ProjectName = vals[0]
			case "data.applicationID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ApplicationID = val
			case "data.applicationName":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.ApplicationName = vals[0]
			case "data.branch":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Branch = vals[0]
			case "data.commit":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				m.Data.Commit = vals[0]
			case "data.commitDetail":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
			case "data.commitDetail.commitID":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.CommitID = vals[0]
			case "data.commitDetail.repo":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Repo = vals[0]
			case "data.commitDetail.repoAbbr":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.RepoAbbr = vals[0]
			case "data.commitDetail.author":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Author = vals[0]
			case "data.commitDetail.email":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Email = vals[0]
			case "data.commitDetail.time":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
			case "data.commitDetail.time.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CommitDetail.Time.Seconds = val
			case "data.commitDetail.time.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				if m.Data.CommitDetail.Time == nil {
					m.Data.CommitDetail.Time = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.CommitDetail.Time.Nanos = int32(val)
			case "data.commitDetail.comment":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.CommitDetail == nil {
					m.Data.CommitDetail = &pb.CommitDetail{}
				}
				m.Data.CommitDetail.Comment = vals[0]
			case "data.progress":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Progress = val
			case "data.costTimeSec":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CostTimeSec = val
			case "data.timeBegin":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
			case "data.timeBegin.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Seconds = val
			case "data.timeBegin.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Nanos = int32(val)
			case "data.timeEnd":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
			case "data.timeEnd.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Seconds = val
			case "data.timeEnd.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Nanos = int32(val)
			case "data.timeCreated":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
			case "data.timeCreated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Seconds = val
			case "data.timeCreated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Nanos = int32(val)
			case "data.timeUpdated":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "data.timeUpdated.seconds":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Seconds = val
			case "data.timeUpdated.nanos":
				if m.Data == nil {
					m.Data = &PipelineInstance{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelineTaskDetailRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskDetailRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "taskID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TaskID = val
			}
		}
	}
	return nil
}

// PipelineTaskDetailResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskDetailResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "data":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
			case "data.ID":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.ID = val
			case "data.pipelineID":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.PipelineID = val
			case "data.stageID":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.StageID = val
			case "data.name":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				m.Data.Name = vals[0]
			case "data.type":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				m.Data.Type = vals[0]
			case "data.status":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				m.Data.Status = vals[0]
			case "data.extra":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineTaskExtra{}
				}
			case "data.extra.UUID":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineTaskExtra{}
				}
				m.Data.Extra.UUID = vals[0]
			case "data.extra.allowFailure":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Extra == nil {
					m.Data.Extra = &PipelineTaskExtra{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.Extra.AllowFailure = val
			case "data.result":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
			case "data.result.machineStat":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
			case "data.result.machineStat.host":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
			case "data.result.machineStat.host.hostIP":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Data.Result.MachineStat.Host.HostIP = vals[0]
			case "data.result.machineStat.host.hostname":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Data.Result.MachineStat.Host.Hostname = vals[0]
			case "data.result.machineStat.host.uptimeSec":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Host.UptimeSec = val
			case "data.result.machineStat.host.bootTimeSec":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Host.BootTimeSec = val
			case "data.result.machineStat.host.OS":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Data.Result.MachineStat.Host.OS = vals[0]
			case "data.result.machineStat.host.platform":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Data.Result.MachineStat.Host.Platform = vals[0]
			case "data.result.machineStat.host.platformVersion":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Data.Result.MachineStat.Host.PlatformVersion = vals[0]
			case "data.result.machineStat.host.kernelVersion":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Data.Result.MachineStat.Host.KernelVersion = vals[0]
			case "data.result.machineStat.host.kernelArch":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Host == nil {
					m.Data.Result.MachineStat.Host = &PipelineTaskMachineHostStat{}
				}
				m.Data.Result.MachineStat.Host.KernelArch = vals[0]
			case "data.result.machineStat.pod":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Pod == nil {
					m.Data.Result.MachineStat.Pod = &PipelineTaskMachinePodStat{}
				}
			case "data.result.machineStat.pod.podIP":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Pod == nil {
					m.Data.Result.MachineStat.Pod = &PipelineTaskMachinePodStat{}
				}
				m.Data.Result.MachineStat.Pod.PodIP = vals[0]
			case "data.result.machineStat.load":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Load == nil {
					m.Data.Result.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
			case "data.result.machineStat.load.load1":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Load == nil {
					m.Data.Result.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Load.Load1 = val
			case "data.result.machineStat.load.load5":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Load == nil {
					m.Data.Result.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Load.Load5 = val
			case "data.result.machineStat.load.load15":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Load == nil {
					m.Data.Result.MachineStat.Load = &PipelineTaskMachineLoadStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Load.Load15 = val
			case "data.result.machineStat.mem":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Mem == nil {
					m.Data.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
			case "data.result.machineStat.mem.total":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Mem == nil {
					m.Data.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Mem.Total = val
			case "data.result.machineStat.mem.available":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Mem == nil {
					m.Data.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Mem.Available = val
			case "data.result.machineStat.mem.used":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Mem == nil {
					m.Data.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Mem.Used = val
			case "data.result.machineStat.mem.free":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Mem == nil {
					m.Data.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Mem.Free = val
			case "data.result.machineStat.mem.usedPercent":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Mem == nil {
					m.Data.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Mem.UsedPercent = val
			case "data.result.machineStat.mem.buffers":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Mem == nil {
					m.Data.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Mem.Buffers = val
			case "data.result.machineStat.mem.cached":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Mem == nil {
					m.Data.Result.MachineStat.Mem = &PipelineTaskMachineMemStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Mem.Cached = val
			case "data.result.machineStat.swap":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Swap == nil {
					m.Data.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
			case "data.result.machineStat.swap.total":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Swap == nil {
					m.Data.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Swap.Total = val
			case "data.result.machineStat.swap.used":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Swap == nil {
					m.Data.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Swap.Used = val
			case "data.result.machineStat.swap.free":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Swap == nil {
					m.Data.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Swap.Free = val
			case "data.result.machineStat.swap.usedPercent":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.Result == nil {
					m.Data.Result = &PipelineTaskResult{}
				}
				if m.Data.Result.MachineStat == nil {
					m.Data.Result.MachineStat = &PipelineTaskMachineStat{}
				}
				if m.Data.Result.MachineStat.Swap == nil {
					m.Data.Result.MachineStat.Swap = &PipelineTaskMachineSwapStat{}
				}
				val, err := strconv.ParseFloat(vals[0], 64)
				if err != nil {
					return err
				}
				m.Data.Result.MachineStat.Swap.UsedPercent = val
			case "data.isSnippet":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.IsSnippet = val
			case "data.snippetPipelineID":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.SnippetPipelineID = val
			case "data.snippetPipelineDetail":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.SnippetPipelineDetail == nil {
					m.Data.SnippetPipelineDetail = &PipelineTaskSnippetDetail{}
				}
			case "data.snippetPipelineDetail.directSnippetTaskNum":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.SnippetPipelineDetail == nil {
					m.Data.SnippetPipelineDetail = &PipelineTaskSnippetDetail{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.SnippetPipelineDetail.DirectSnippetTaskNum = val
			case "data.snippetPipelineDetail.recursiveSnippetTaskNum":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.SnippetPipelineDetail == nil {
					m.Data.SnippetPipelineDetail = &PipelineTaskSnippetDetail{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.SnippetPipelineDetail.RecursiveSnippetTaskNum = val
			case "data.costTimeSec":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.CostTimeSec = val
			case "data.queueTimeSec":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.QueueTimeSec = val
			case "data.timeBegin":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
			case "data.timeBegin.seconds":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Seconds = val
			case "data.timeBegin.nanos":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeBegin == nil {
					m.Data.TimeBegin = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeBegin.Nanos = int32(val)
			case "data.timeEnd":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
			case "data.timeEnd.seconds":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Seconds = val
			case "data.timeEnd.nanos":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeEnd == nil {
					m.Data.TimeEnd = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeEnd.Nanos = int32(val)
			case "data.timeCreated":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
			case "data.timeCreated.seconds":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Seconds = val
			case "data.timeCreated.nanos":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeCreated == nil {
					m.Data.TimeCreated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeCreated.Nanos = int32(val)
			case "data.timeUpdated":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
			case "data.timeUpdated.seconds":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Seconds = val
			case "data.timeUpdated.nanos":
				if m.Data == nil {
					m.Data = &PipelineTask{}
				}
				if m.Data.TimeUpdated == nil {
					m.Data.TimeUpdated = &timestamppb.Timestamp{}
				}
				val, err := strconv.ParseInt(vals[0], 10, 32)
				if err != nil {
					return err
				}
				m.Data.TimeUpdated.Nanos = int32(val)
			}
		}
	}
	return nil
}

// PipelineTaskGetBootstrapInfoRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskGetBootstrapInfoRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.PipelineID = val
			case "taskID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.TaskID = val
			}
		}
	}
	return nil
}

// PipelineTaskGetBootstrapInfoResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineTaskGetBootstrapInfoResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "data":
				val, err := base64.StdEncoding.DecodeString(vals[0])
				if err != nil {
					return err
				}
				m.Data = val
			}
		}
	}
	return nil
}

// DeprecatedPipelineBatchCreateRequest implement urlenc.URLValuesUnmarshaler.
func (m *DeprecatedPipelineBatchCreateRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "appID":
				val, err := strconv.ParseUint(vals[0], 10, 64)
				if err != nil {
					return err
				}
				m.AppID = val
			case "branch":
				m.Branch = vals[0]
			case "source":
				m.Source = vals[0]
			case "batchPipelineYmlPaths":
				m.BatchPipelineYmlPaths = vals
			case "autoRun":
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.AutoRun = val
			case "callbackURLs":
				m.CallbackURLs = vals
			case "userID":
				m.UserID = vals[0]
			}
		}
	}
	return nil
}

// DeprecatedPipelineBatchCreateResponse implement urlenc.URLValuesUnmarshaler.
func (m *DeprecatedPipelineBatchCreateResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	return nil
}

// PipelineYmlGraphRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineYmlGraphRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "pipelineYmlContent":
				m.PipelineYmlContent = vals[0]
			case "snippetConfig":
				if m.SnippetConfig == nil {
					m.SnippetConfig = &SnippetConfig{}
				}
			case "snippetConfig.source":
				if m.SnippetConfig == nil {
					m.SnippetConfig = &SnippetConfig{}
				}
				m.SnippetConfig.Source = vals[0]
			case "snippetConfig.name":
				if m.SnippetConfig == nil {
					m.SnippetConfig = &SnippetConfig{}
				}
				m.SnippetConfig.Name = vals[0]
			}
		}
	}
	return nil
}

// PipelineYmlGraphResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineYmlGraphResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "data":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
			case "data.version":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				m.Data.Version = vals[0]
			case "data.cron":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				m.Data.Cron = vals[0]
			case "data.cronCompensator":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.CronCompensator == nil {
					m.Data.CronCompensator = &CronCompensator{}
				}
			case "data.cronCompensator.enable":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.CronCompensator == nil {
					m.Data.CronCompensator = &CronCompensator{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.CronCompensator.Enable = val
			case "data.cronCompensator.latestFirst":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.CronCompensator == nil {
					m.Data.CronCompensator = &CronCompensator{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.CronCompensator.LatestFirst = val
			case "data.cronCompensator.stopIfLatterExecuted":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.CronCompensator == nil {
					m.Data.CronCompensator = &CronCompensator{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.CronCompensator.StopIfLatterExecuted = val
			case "data.stages":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.Stages == nil {
					m.Data.Stages = &structpb.ListValue{}
				}
			case "data.needUpgrade":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				val, err := strconv.ParseBool(vals[0])
				if err != nil {
					return err
				}
				m.Data.NeedUpgrade = val
			case "data.ymlContent":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				m.Data.YmlContent = vals[0]
			case "data.on":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.On == nil {
					m.Data.On = &TriggerConfig{}
				}
			case "data.on.push":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.On == nil {
					m.Data.On = &TriggerConfig{}
				}
				if m.Data.On.Push == nil {
					m.Data.On.Push = &PushTrigger{}
				}
			case "data.on.push.branches":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.On == nil {
					m.Data.On = &TriggerConfig{}
				}
				if m.Data.On.Push == nil {
					m.Data.On.Push = &PushTrigger{}
				}
				m.Data.On.Push.Branches = vals
			case "data.on.push.tags":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.On == nil {
					m.Data.On = &TriggerConfig{}
				}
				if m.Data.On.Push == nil {
					m.Data.On.Push = &PushTrigger{}
				}
				m.Data.On.Push.Tags = vals
			case "data.on.merge":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.On == nil {
					m.Data.On = &TriggerConfig{}
				}
				if m.Data.On.Merge == nil {
					m.Data.On.Merge = &MergeTrigger{}
				}
			case "data.on.merge.branches":
				if m.Data == nil {
					m.Data = &PipelineYml{}
				}
				if m.Data.On == nil {
					m.Data.On = &TriggerConfig{}
				}
				if m.Data.On.Merge == nil {
					m.Data.On.Merge = &MergeTrigger{}
				}
				m.Data.On.Merge.Branches = vals
			}
		}
	}
	return nil
}

// PipelineCallbackRequest implement urlenc.URLValuesUnmarshaler.
func (m *PipelineCallbackRequest) UnmarshalURLValues(prefix string, values url.Values) error {
	for key, vals := range values {
		if len(vals) > 0 {
			switch prefix + key {
			case "type":
				m.Type = vals[0]
			case "data":
				val, err := base64.StdEncoding.DecodeString(vals[0])
				if err != nil {
					return err
				}
				m.Data = val
			}
		}
	}
	return nil
}

// PipelineCallbackResponse implement urlenc.URLValuesUnmarshaler.
func (m *PipelineCallbackResponse) UnmarshalURLValues(prefix string, values url.Values) error {
	return nil
}