pipeline.go

// Code generated by go-swagger; DO NOT EDIT.

package models

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"bytes"
	"context"
	"encoding/json"
	"io"
	"strconv"

	"github.com/go-openapi/errors"
	"github.com/go-openapi/runtime"
	"github.com/go-openapi/strfmt"
	"github.com/go-openapi/swag"
	"github.com/go-openapi/validate"
)

// Pipeline Pipeline
//
// A pipeline is a continuous integration and delivery model of your software release process, from your source code, through testing, to production. It includes a sequence of stages with tasks that represent the activities in your software release cycle. Your software application flows from one stage to the next through the pipeline.
//
// swagger:discriminator Pipeline A pipeline is a continuous integration and delivery model of your software release process, from your source code, through testing, to production. It includes a sequence of stages with tasks that represent the activities in your software release cycle. Your software application flows from one stage to the next through the pipeline.
type Pipeline interface {
	runtime.Validatable
	runtime.ContextValidatable

	// This field is provided for backward compatibility. Contains the same value as the 'createdAt' field as a UNIX timestamp in microseconds
	// Example: 1568625938000000
	CreateTimeInMicros() int64
	SetCreateTimeInMicros(int64)

	// Additional information about Input Properties
	// Example: {"test":{"description":"test-value","mandatory":false}}
	InputMeta() map[string]PropertyMetaData
	SetInputMeta(map[string]PropertyMetaData)

	// Partial URL that provides details of the resource.
	// Example: /codestream/api/\u003cprefix\u003e/8365ef3b-8bf3-48aa-bd5d-7113fcff827c
	Link() string
	SetLink(string)

	// Contains project id of the entity
	// Example: abcd-abcd-abcd
	ProjectID() string
	SetProjectID(string)

	// This field is provided for backward compatibility. Contains the same value as the 'updatedAt' field as a UNIX timestamp in microseconds
	// Example: 1568625938000000
	UpdateTimeInMicros() int64
	SetUpdateTimeInMicros(int64)

	Warnings() []ValidatorResponse
	SetWarnings([]ValidatorResponse)

	// Number of Executions of the Pipeline that can run concurrently.
	// Example: 10
	Concurrency() int32
	SetConcurrency(int32)

	// Date when the entity was created. The date is in ISO 8601 with time zone
	// Example: 2019-09-16 09:25:38.065065+00
	CreatedAt() string
	SetCreatedAt(string)

	// The user that created this entity
	// Example: exampleuser
	CreatedBy() string
	SetCreatedBy(string)

	// A human-friendly description.
	// Required: true
	Description() *string
	SetDescription(*string)

	// Indicates if the Pipeline is in enabled state.
	// Example: true
	Enabled() bool
	SetEnabled(bool)

	// Indicates if the pipeline is shared with all projects in an Org.
	// Example: true
	Global() bool
	SetGlobal(bool)

	// String description of the icon used for this Pipeline.
	// Example: tools,,is-success is-solid
	Icon() string
	SetIcon(string)

	// The id of this resource.
	// Example: 8365ef3b-8bf3-48aa-bd5d-7113fcff827c
	ID() string
	SetID(string)

	// Map representing the Input properties for the Pipeline.
	// Example: [{"ip":"10.5.23.84","script":"testScript.sh"}]
	Input() interface{}
	SetInput(interface{})

	// A human-friendly name used as an identifier in APIs that support this option
	// Example: My-Name
	// Required: true
	Name() *string
	SetName(*string)

	Notifications() NotificationConfiguration
	SetNotifications(NotificationConfiguration)

	// Represents the different options to trigger a Pipeline. Selecting an option auto injects the Input properties needed to execute a Pipeline with that trigger.
	// Example: ["DOCKER_TRIGGER"]
	Options() []string
	SetOptions([]string)

	// Map representing the Output properties for the Pipeline.
	// Example: [{"deployedMachineIP":"10.108.35.54","result":"true"}]
	Output() interface{}
	SetOutput(interface{})

	// The project this entity belongs to.
	// Example: My-Project
	Project() string
	SetProject(string)

	Rollbacks() []RollbackConfiguration
	SetRollbacks([]RollbackConfiguration)

	// Represents the order in which Stages will be executed.
	// Example: ["AcquireToken","Upgrade","E2E"]
	StageOrder() []string
	SetStageOrder([]string)

	// Map representing the details of the various Stages of the Pipeline.
	Stages() map[string]Stage
	SetStages(map[string]Stage)

	// Highlights any given Input/Output properties
	// Example: {"test-output":"${Stage0.Task0.status}"}
	Starred() *PipelineStarredProperty
	SetStarred(*PipelineStarredProperty)

	// Indicates if the Pipeline is enabled/disabled/released to catalog.
	// Example: RELEASED
	State() string
	SetState(string)

	// A set of tag keys and optional values that were set on on the resource.
	// Example: [{"key":"env","value":"dev"}]
	Tags() []string
	SetTags([]string)

	// Date when the entity was last updated. The date is in ISO 8601 with time zone.
	// Example: 2019-09-16 09:25:38.065065+00
	UpdatedAt() string
	SetUpdatedAt(string)

	// The user that last updated this entity
	// Example: exampleuser
	UpdatedBy() string
	SetUpdatedBy(string)

	// Version of the resource.
	// Example: v1
	Version() string
	SetVersion(string)

	// Represents the configuration to be used for CI and Custom tasks.
	Workspace() *Workspace
	SetWorkspace(*Workspace)

	// AdditionalProperties in base type shoud be handled just like regular properties
	// At this moment, the base type property is pushed down to the subtype
}

type pipeline struct {
	createTimeInMicrosField int64

	inputMetaField map[string]PropertyMetaData

	linkField string

	projectIdField string

	updateTimeInMicrosField int64

	warningsField []ValidatorResponse

	concurrencyField int32

	createdAtField string

	createdByField string

	descriptionField *string

	enabledField bool

	globalField bool

	iconField string

	idField string

	inputField interface{}

	nameField *string

	notificationsField NotificationConfiguration

	optionsField []string

	outputField interface{}

	projectField string

	rollbacksField []RollbackConfiguration

	stageOrderField []string

	stagesField map[string]Stage

	starredField *PipelineStarredProperty

	stateField string

	tagsField []string

	updatedAtField string

	updatedByField string

	versionField string

	workspaceField *Workspace
}

// CreateTimeInMicros gets the create time in micros of this polymorphic type
func (m *pipeline) CreateTimeInMicros() int64 {
	return m.createTimeInMicrosField
}

// SetCreateTimeInMicros sets the create time in micros of this polymorphic type
func (m *pipeline) SetCreateTimeInMicros(val int64) {
	m.createTimeInMicrosField = val
}

// InputMeta gets the input meta of this polymorphic type
func (m *pipeline) InputMeta() map[string]PropertyMetaData {
	return m.inputMetaField
}

// SetInputMeta sets the input meta of this polymorphic type
func (m *pipeline) SetInputMeta(val map[string]PropertyMetaData) {
	m.inputMetaField = val
}

// Link gets the link of this polymorphic type
func (m *pipeline) Link() string {
	return m.linkField
}

// SetLink sets the link of this polymorphic type
func (m *pipeline) SetLink(val string) {
	m.linkField = val
}

// ProjectID gets the project Id of this polymorphic type
func (m *pipeline) ProjectID() string {
	return m.projectIdField
}

// SetProjectID sets the project Id of this polymorphic type
func (m *pipeline) SetProjectID(val string) {
	m.projectIdField = val
}

// UpdateTimeInMicros gets the update time in micros of this polymorphic type
func (m *pipeline) UpdateTimeInMicros() int64 {
	return m.updateTimeInMicrosField
}

// SetUpdateTimeInMicros sets the update time in micros of this polymorphic type
func (m *pipeline) SetUpdateTimeInMicros(val int64) {
	m.updateTimeInMicrosField = val
}

// Warnings gets the warnings of this polymorphic type
func (m *pipeline) Warnings() []ValidatorResponse {
	return m.warningsField
}

// SetWarnings sets the warnings of this polymorphic type
func (m *pipeline) SetWarnings(val []ValidatorResponse) {
	m.warningsField = val
}

// Concurrency gets the concurrency of this polymorphic type
func (m *pipeline) Concurrency() int32 {
	return m.concurrencyField
}

// SetConcurrency sets the concurrency of this polymorphic type
func (m *pipeline) SetConcurrency(val int32) {
	m.concurrencyField = val
}

// CreatedAt gets the created at of this polymorphic type
func (m *pipeline) CreatedAt() string {
	return m.createdAtField
}

// SetCreatedAt sets the created at of this polymorphic type
func (m *pipeline) SetCreatedAt(val string) {
	m.createdAtField = val
}

// CreatedBy gets the created by of this polymorphic type
func (m *pipeline) CreatedBy() string {
	return m.createdByField
}

// SetCreatedBy sets the created by of this polymorphic type
func (m *pipeline) SetCreatedBy(val string) {
	m.createdByField = val
}

// Description gets the description of this polymorphic type
func (m *pipeline) Description() *string {
	return m.descriptionField
}

// SetDescription sets the description of this polymorphic type
func (m *pipeline) SetDescription(val *string) {
	m.descriptionField = val
}

// Enabled gets the enabled of this polymorphic type
func (m *pipeline) Enabled() bool {
	return m.enabledField
}

// SetEnabled sets the enabled of this polymorphic type
func (m *pipeline) SetEnabled(val bool) {
	m.enabledField = val
}

// Global gets the global of this polymorphic type
func (m *pipeline) Global() bool {
	return m.globalField
}

// SetGlobal sets the global of this polymorphic type
func (m *pipeline) SetGlobal(val bool) {
	m.globalField = val
}

// Icon gets the icon of this polymorphic type
func (m *pipeline) Icon() string {
	return m.iconField
}

// SetIcon sets the icon of this polymorphic type
func (m *pipeline) SetIcon(val string) {
	m.iconField = val
}

// ID gets the id of this polymorphic type
func (m *pipeline) ID() string {
	return m.idField
}

// SetID sets the id of this polymorphic type
func (m *pipeline) SetID(val string) {
	m.idField = val
}

// Input gets the input of this polymorphic type
func (m *pipeline) Input() interface{} {
	return m.inputField
}

// SetInput sets the input of this polymorphic type
func (m *pipeline) SetInput(val interface{}) {
	m.inputField = val
}

// Name gets the name of this polymorphic type
func (m *pipeline) Name() *string {
	return m.nameField
}

// SetName sets the name of this polymorphic type
func (m *pipeline) SetName(val *string) {
	m.nameField = val
}

// Notifications gets the notifications of this polymorphic type
func (m *pipeline) Notifications() NotificationConfiguration {
	return m.notificationsField
}

// SetNotifications sets the notifications of this polymorphic type
func (m *pipeline) SetNotifications(val NotificationConfiguration) {
	m.notificationsField = val
}

// Options gets the options of this polymorphic type
func (m *pipeline) Options() []string {
	return m.optionsField
}

// SetOptions sets the options of this polymorphic type
func (m *pipeline) SetOptions(val []string) {
	m.optionsField = val
}

// Output gets the output of this polymorphic type
func (m *pipeline) Output() interface{} {
	return m.outputField
}

// SetOutput sets the output of this polymorphic type
func (m *pipeline) SetOutput(val interface{}) {
	m.outputField = val
}

// Project gets the project of this polymorphic type
func (m *pipeline) Project() string {
	return m.projectField
}

// SetProject sets the project of this polymorphic type
func (m *pipeline) SetProject(val string) {
	m.projectField = val
}

// Rollbacks gets the rollbacks of this polymorphic type
func (m *pipeline) Rollbacks() []RollbackConfiguration {
	return m.rollbacksField
}

// SetRollbacks sets the rollbacks of this polymorphic type
func (m *pipeline) SetRollbacks(val []RollbackConfiguration) {
	m.rollbacksField = val
}

// StageOrder gets the stage order of this polymorphic type
func (m *pipeline) StageOrder() []string {
	return m.stageOrderField
}

// SetStageOrder sets the stage order of this polymorphic type
func (m *pipeline) SetStageOrder(val []string) {
	m.stageOrderField = val
}

// Stages gets the stages of this polymorphic type
func (m *pipeline) Stages() map[string]Stage {
	return m.stagesField
}

// SetStages sets the stages of this polymorphic type
func (m *pipeline) SetStages(val map[string]Stage) {
	m.stagesField = val
}

// Starred gets the starred of this polymorphic type
func (m *pipeline) Starred() *PipelineStarredProperty {
	return m.starredField
}

// SetStarred sets the starred of this polymorphic type
func (m *pipeline) SetStarred(val *PipelineStarredProperty) {
	m.starredField = val
}

// State gets the state of this polymorphic type
func (m *pipeline) State() string {
	return m.stateField
}

// SetState sets the state of this polymorphic type
func (m *pipeline) SetState(val string) {
	m.stateField = val
}

// Tags gets the tags of this polymorphic type
func (m *pipeline) Tags() []string {
	return m.tagsField
}

// SetTags sets the tags of this polymorphic type
func (m *pipeline) SetTags(val []string) {
	m.tagsField = val
}

// UpdatedAt gets the updated at of this polymorphic type
func (m *pipeline) UpdatedAt() string {
	return m.updatedAtField
}

// SetUpdatedAt sets the updated at of this polymorphic type
func (m *pipeline) SetUpdatedAt(val string) {
	m.updatedAtField = val
}

// UpdatedBy gets the updated by of this polymorphic type
func (m *pipeline) UpdatedBy() string {
	return m.updatedByField
}

// SetUpdatedBy sets the updated by of this polymorphic type
func (m *pipeline) SetUpdatedBy(val string) {
	m.updatedByField = val
}

// Version gets the version of this polymorphic type
func (m *pipeline) Version() string {
	return m.versionField
}

// SetVersion sets the version of this polymorphic type
func (m *pipeline) SetVersion(val string) {
	m.versionField = val
}

// Workspace gets the workspace of this polymorphic type
func (m *pipeline) Workspace() *Workspace {
	return m.workspaceField
}

// SetWorkspace sets the workspace of this polymorphic type
func (m *pipeline) SetWorkspace(val *Workspace) {
	m.workspaceField = val
}

// UnmarshalPipelineSlice unmarshals polymorphic slices of Pipeline
func UnmarshalPipelineSlice(reader io.Reader, consumer runtime.Consumer) ([]Pipeline, error) {
	var elements []json.RawMessage
	if err := consumer.Consume(reader, &elements); err != nil {
		return nil, err
	}

	var result []Pipeline
	for _, element := range elements {
		obj, err := unmarshalPipeline(element, consumer)
		if err != nil {
			return nil, err
		}
		result = append(result, obj)
	}
	return result, nil
}

// UnmarshalPipeline unmarshals polymorphic Pipeline
func UnmarshalPipeline(reader io.Reader, consumer runtime.Consumer) (Pipeline, error) {
	// we need to read this twice, so first into a buffer
	data, err := io.ReadAll(reader)
	if err != nil {
		return nil, err
	}
	return unmarshalPipeline(data, consumer)
}

func unmarshalPipeline(data []byte, consumer runtime.Consumer) (Pipeline, error) {
	buf := bytes.NewBuffer(data)
	buf2 := bytes.NewBuffer(data)

	// the first time this is read is to fetch the value of the A pipeline is a continuous integration and delivery model of your software release process, from your source code, through testing, to production. It includes a sequence of stages with tasks that represent the activities in your software release cycle. Your software application flows from one stage to the next through the pipeline. property.
	var getType struct {
		APipelineIsaContinuousIntegrationAndDeliveryModelOfYourSoftwareReleaseProcessFromYourSourceCodeThroughTestingToProductionItIncludesaSequenceOfStagesWithTasksThatRepresentTheActivitiesInYourSoftwareReleaseCycleYourSoftwareApplicationFlowsFromOneStageToTheNextThroughThePipeline string `json:"A pipeline is a continuous integration and delivery model of your software release process, from your source code, through testing, to production. It includes a sequence of stages with tasks that represent the activities in your software release cycle. Your software application flows from one stage to the next through the pipeline."`
	}
	if err := consumer.Consume(buf, &getType); err != nil {
		return nil, err
	}

	if err := validate.RequiredString("A pipeline is a continuous integration and delivery model of your software release process, from your source code, through testing, to production. It includes a sequence of stages with tasks that represent the activities in your software release cycle. Your software application flows from one stage to the next through the pipeline.", "body", getType.APipelineIsaContinuousIntegrationAndDeliveryModelOfYourSoftwareReleaseProcessFromYourSourceCodeThroughTestingToProductionItIncludesaSequenceOfStagesWithTasksThatRepresentTheActivitiesInYourSoftwareReleaseCycleYourSoftwareApplicationFlowsFromOneStageToTheNextThroughThePipeline); err != nil {
		return nil, err
	}

	// The value of A pipeline is a continuous integration and delivery model of your software release process, from your source code, through testing, to production. It includes a sequence of stages with tasks that represent the activities in your software release cycle. Your software application flows from one stage to the next through the pipeline. is used to determine which type to create and unmarshal the data into
	switch getType.APipelineIsaContinuousIntegrationAndDeliveryModelOfYourSoftwareReleaseProcessFromYourSourceCodeThroughTestingToProductionItIncludesaSequenceOfStagesWithTasksThatRepresentTheActivitiesInYourSoftwareReleaseCycleYourSoftwareApplicationFlowsFromOneStageToTheNextThroughThePipeline {
	case "Pipeline":
		var result pipeline
		if err := consumer.Consume(buf2, &result); err != nil {
			return nil, err
		}
		return &result, nil
	}
	return nil, errors.New(422, "invalid A pipeline is a continuous integration and delivery model of your software release process, from your source code, through testing, to production. It includes a sequence of stages with tasks that represent the activities in your software release cycle. Your software application flows from one stage to the next through the pipeline. value: %q", getType.APipelineIsaContinuousIntegrationAndDeliveryModelOfYourSoftwareReleaseProcessFromYourSourceCodeThroughTestingToProductionItIncludesaSequenceOfStagesWithTasksThatRepresentTheActivitiesInYourSoftwareReleaseCycleYourSoftwareApplicationFlowsFromOneStageToTheNextThroughThePipeline)
}

// Validate validates this pipeline
func (m *pipeline) Validate(formats strfmt.Registry) error {
	var res []error

	if err := m.validateInputMeta(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateWarnings(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateDescription(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateName(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateNotifications(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateRollbacks(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateStages(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateStarred(formats); err != nil {
		res = append(res, err)
	}

	if err := m.validateWorkspace(formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *pipeline) validateInputMeta(formats strfmt.Registry) error {
	if swag.IsZero(m.InputMeta()) { // not required
		return nil
	}

	for k := range m.InputMeta() {

		if err := validate.Required("_inputMeta"+"."+k, "body", m.InputMeta()[k]); err != nil {
			return err
		}
		if val, ok := m.InputMeta()[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("_inputMeta" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("_inputMeta" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *pipeline) validateWarnings(formats strfmt.Registry) error {
	if swag.IsZero(m.Warnings()) { // not required
		return nil
	}

	for i := 0; i < len(m.Warnings()); i++ {

		if err := m.warningsField[i].Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("_warnings" + "." + strconv.Itoa(i))
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("_warnings" + "." + strconv.Itoa(i))
			}
			return err
		}

	}

	return nil
}

func (m *pipeline) validateDescription(formats strfmt.Registry) error {

	if err := validate.Required("description", "body", m.Description()); err != nil {
		return err
	}

	return nil
}

func (m *pipeline) validateName(formats strfmt.Registry) error {

	if err := validate.Required("name", "body", m.Name()); err != nil {
		return err
	}

	return nil
}

func (m *pipeline) validateNotifications(formats strfmt.Registry) error {
	if swag.IsZero(m.Notifications()) { // not required
		return nil
	}

	if err := m.Notifications().Validate(formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("notifications")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("notifications")
		}
		return err
	}

	return nil
}

func (m *pipeline) validateRollbacks(formats strfmt.Registry) error {
	if swag.IsZero(m.Rollbacks()) { // not required
		return nil
	}

	for i := 0; i < len(m.Rollbacks()); i++ {

		if err := m.rollbacksField[i].Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("rollbacks" + "." + strconv.Itoa(i))
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("rollbacks" + "." + strconv.Itoa(i))
			}
			return err
		}

	}

	return nil
}

func (m *pipeline) validateStages(formats strfmt.Registry) error {
	if swag.IsZero(m.Stages()) { // not required
		return nil
	}

	for k := range m.Stages() {

		if err := validate.Required("stages"+"."+k, "body", m.Stages()[k]); err != nil {
			return err
		}
		if val, ok := m.Stages()[k]; ok {
			if err := val.Validate(formats); err != nil {
				if ve, ok := err.(*errors.Validation); ok {
					return ve.ValidateName("stages" + "." + k)
				} else if ce, ok := err.(*errors.CompositeError); ok {
					return ce.ValidateName("stages" + "." + k)
				}
				return err
			}
		}

	}

	return nil
}

func (m *pipeline) validateStarred(formats strfmt.Registry) error {
	if swag.IsZero(m.Starred()) { // not required
		return nil
	}

	if m.Starred() != nil {
		if err := m.Starred().Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("starred")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("starred")
			}
			return err
		}
	}

	return nil
}

func (m *pipeline) validateWorkspace(formats strfmt.Registry) error {
	if swag.IsZero(m.Workspace()) { // not required
		return nil
	}

	if m.Workspace() != nil {
		if err := m.Workspace().Validate(formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("workspace")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("workspace")
			}
			return err
		}
	}

	return nil
}

// ContextValidate validate this pipeline based on the context it is used
func (m *pipeline) ContextValidate(ctx context.Context, formats strfmt.Registry) error {
	var res []error

	if err := m.contextValidateInputMeta(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateWarnings(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateNotifications(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateRollbacks(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateStages(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateStarred(ctx, formats); err != nil {
		res = append(res, err)
	}

	if err := m.contextValidateWorkspace(ctx, formats); err != nil {
		res = append(res, err)
	}

	if len(res) > 0 {
		return errors.CompositeValidationError(res...)
	}
	return nil
}

func (m *pipeline) contextValidateInputMeta(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.InputMeta() {

		if val, ok := m.InputMeta()[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *pipeline) contextValidateWarnings(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Warnings()); i++ {

		if err := m.warningsField[i].ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("_warnings" + "." + strconv.Itoa(i))
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("_warnings" + "." + strconv.Itoa(i))
			}
			return err
		}

	}

	return nil
}

func (m *pipeline) contextValidateNotifications(ctx context.Context, formats strfmt.Registry) error {

	if err := m.Notifications().ContextValidate(ctx, formats); err != nil {
		if ve, ok := err.(*errors.Validation); ok {
			return ve.ValidateName("notifications")
		} else if ce, ok := err.(*errors.CompositeError); ok {
			return ce.ValidateName("notifications")
		}
		return err
	}

	return nil
}

func (m *pipeline) contextValidateRollbacks(ctx context.Context, formats strfmt.Registry) error {

	for i := 0; i < len(m.Rollbacks()); i++ {

		if err := m.rollbacksField[i].ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("rollbacks" + "." + strconv.Itoa(i))
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("rollbacks" + "." + strconv.Itoa(i))
			}
			return err
		}

	}

	return nil
}

func (m *pipeline) contextValidateStages(ctx context.Context, formats strfmt.Registry) error {

	for k := range m.Stages() {

		if val, ok := m.Stages()[k]; ok {
			if err := val.ContextValidate(ctx, formats); err != nil {
				return err
			}
		}

	}

	return nil
}

func (m *pipeline) contextValidateStarred(ctx context.Context, formats strfmt.Registry) error {

	if m.Starred() != nil {
		if err := m.Starred().ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("starred")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("starred")
			}
			return err
		}
	}

	return nil
}

func (m *pipeline) contextValidateWorkspace(ctx context.Context, formats strfmt.Registry) error {

	if m.Workspace() != nil {
		if err := m.Workspace().ContextValidate(ctx, formats); err != nil {
			if ve, ok := err.(*errors.Validation); ok {
				return ve.ValidateName("workspace")
			} else if ce, ok := err.(*errors.CompositeError); ok {
				return ce.ValidateName("workspace")
			}
			return err
		}
	}

	return nil
}