awscodepipeline

README

AWS CodePipeline Construct Library

Pipeline

To construct an empty Pipeline:

// Construct an empty Pipeline
pipeline := codepipeline.NewPipeline(this, jsii.String("MyFirstPipeline"))

To give the Pipeline a nice, human-readable name:

// Give the Pipeline a nice, human-readable name
pipeline := codepipeline.NewPipeline(this, jsii.String("MyFirstPipeline"), &PipelineProps{
	PipelineName: jsii.String("MyPipeline"),
})

Be aware that in the default configuration, the Pipeline construct creates an AWS Key Management Service (AWS KMS) Customer Master Key (CMK) for you to encrypt the artifacts in the artifact bucket, which incurs a cost of $1/month. This default configuration is necessary to allow cross-account actions.

If you do not intend to perform cross-account deployments, you can disable the creation of the Customer Master Keys by passing crossAccountKeys: false when defining the Pipeline:

// Don't create Customer Master Keys
pipeline := codepipeline.NewPipeline(this, jsii.String("MyFirstPipeline"), &PipelineProps{
	CrossAccountKeys: jsii.Boolean(false),
})

If you want to enable key rotation for the generated KMS keys, you can configure it by passing enableKeyRotation: true when creating the pipeline. Note that key rotation will incur an additional cost of $1/month.

// Enable key rotation for the generated KMS key
pipeline := codepipeline.NewPipeline(this, jsii.String("MyFirstPipeline"), &PipelineProps{
	// ...
	EnableKeyRotation: jsii.Boolean(true),
})

Stages

You can provide Stages when creating the Pipeline:

// Provide a Stage when creating a pipeline
pipeline := codepipeline.NewPipeline(this, jsii.String("MyFirstPipeline"), &PipelineProps{
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
			},
		},
	},
})

Or append a Stage to an existing Pipeline:

// Append a Stage to an existing Pipeline
var pipeline pipeline

sourceStage := pipeline.AddStage(&StageOptions{
	StageName: jsii.String("Source"),
	Actions: []iAction{
	},
})

You can insert the new Stage at an arbitrary point in the Pipeline:

// Insert a new Stage at an arbitrary point
var pipeline pipeline
var anotherStage iStage
var yetAnotherStage iStage


someStage := pipeline.AddStage(&StageOptions{
	StageName: jsii.String("SomeStage"),
	Placement: &StagePlacement{
		// note: you can only specify one of the below properties
		RightBefore: anotherStage,
		JustAfter: yetAnotherStage,
	},
})

You can disable transition to a Stage:

// Disable transition to a stage
var pipeline pipeline


someStage := pipeline.AddStage(&StageOptions{
	StageName: jsii.String("SomeStage"),
	TransitionToEnabled: jsii.Boolean(false),
	TransitionDisabledReason: jsii.String("Manual transition only"),
})

This is useful if you don't want every executions of the pipeline to flow into this stage automatically. The transition can then be "manually" enabled later on.

Actions

Actions live in a separate package, aws-cdk-lib/aws-codepipeline-actions.

To add an Action to a Stage, you can provide it when creating the Stage, in the actions property, or you can use the IStage.addAction() method to mutate an existing Stage:

// Use the `IStage.addAction()` method to mutate an existing Stage.
var sourceStage iStage
var someAction action

sourceStage.AddAction(someAction)

Custom Action Registration

To make your own custom CodePipeline Action requires registering the action provider. Look to the JenkinsProvider in aws-cdk-lib/aws-codepipeline-actions for an implementation example.

// Make a custom CodePipeline Action
// Make a custom CodePipeline Action
codepipeline.NewCustomActionRegistration(this, jsii.String("GenericGitSourceProviderResource"), &CustomActionRegistrationProps{
	Category: codepipeline.ActionCategory_SOURCE,
	ArtifactBounds: &ActionArtifactBounds{
		MinInputs: jsii.Number(0),
		MaxInputs: jsii.Number(0),
		MinOutputs: jsii.Number(1),
		MaxOutputs: jsii.Number(1),
	},
	Provider: jsii.String("GenericGitSource"),
	Version: jsii.String("1"),
	EntityUrl: jsii.String("https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html"),
	ExecutionUrl: jsii.String("https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html"),
	ActionProperties: []customActionProperty{
		&customActionProperty{
			Name: jsii.String("Branch"),
			Required: jsii.Boolean(true),
			Key: jsii.Boolean(false),
			Secret: jsii.Boolean(false),
			Queryable: jsii.Boolean(false),
			Description: jsii.String("Git branch to pull"),
			Type: jsii.String("String"),
		},
		&customActionProperty{
			Name: jsii.String("GitUrl"),
			Required: jsii.Boolean(true),
			Key: jsii.Boolean(false),
			Secret: jsii.Boolean(false),
			Queryable: jsii.Boolean(false),
			Description: jsii.String("SSH git clone URL"),
			Type: jsii.String("String"),
		},
	},
})

Cross-account CodePipelines

Cross-account Pipeline actions require that the Pipeline has not been created with crossAccountKeys: false.

Most pipeline Actions accept an AWS resource object to operate on. For example:

• S3DeployAction accepts an s3.IBucket.
• CodeBuildAction accepts a codebuild.IProject.
• etc.

These resources can be either newly defined (new s3.Bucket(...)) or imported (s3.Bucket.fromBucketAttributes(...)) and identify the resource that should be changed.

These resources can be in different accounts than the pipeline itself. For example, the following action deploys to an imported S3 bucket from a different account:

// Deploy an imported S3 bucket from a different account
var stage iStage
var input artifact

stage.AddAction(codepipeline_actions.NewS3DeployAction(&S3DeployActionProps{
	Bucket: s3.Bucket_FromBucketAttributes(this, jsii.String("Bucket"), &BucketAttributes{
		Account: jsii.String("123456789012"),
	}),
	Input: input,
	ActionName: jsii.String("s3-deploy-action"),
}))

Actions that don't accept a resource object accept an explicit account parameter:

// Actions that don't accept a resource objet accept an explicit `account` parameter
var stage iStage
var templatePath artifactPath

stage.AddAction(codepipeline_actions.NewCloudFormationCreateUpdateStackAction(&CloudFormationCreateUpdateStackActionProps{
	Account: jsii.String("123456789012"),
	TemplatePath: TemplatePath,
	AdminPermissions: jsii.Boolean(false),
	StackName: awscdk.*stack_Of(this).stackName,
	ActionName: jsii.String("cloudformation-create-update"),
}))

The Pipeline construct automatically defines an IAM Role for you in the target account which the pipeline will assume to perform that action. This Role will be defined in a support stack named <PipelineStackName>-support-<account>, that will automatically be deployed before the stack containing the pipeline.

If you do not want to use the generated role, you can also explicitly pass a role when creating the action. In that case, the action will operate in the account the role belongs to:

// Explicitly pass in a `role` when creating an action.
var stage iStage
var templatePath artifactPath

stage.AddAction(codepipeline_actions.NewCloudFormationCreateUpdateStackAction(&CloudFormationCreateUpdateStackActionProps{
	TemplatePath: TemplatePath,
	AdminPermissions: jsii.Boolean(false),
	StackName: awscdk.*stack_Of(this).stackName,
	ActionName: jsii.String("cloudformation-create-update"),
	// ...
	Role: iam.Role_FromRoleArn(this, jsii.String("ActionRole"), jsii.String("...")),
}))

Cross-region CodePipelines

Similar to how you set up a cross-account Action, the AWS resource object you pass to actions can also be in different Regions. For example, the following Action deploys to an imported S3 bucket from a different Region:

// Deploy to an imported S3 bucket from a different Region.
var stage iStage
var input artifact

stage.AddAction(codepipeline_actions.NewS3DeployAction(&S3DeployActionProps{
	Bucket: s3.Bucket_FromBucketAttributes(this, jsii.String("Bucket"), &BucketAttributes{
		Region: jsii.String("us-west-1"),
	}),
	Input: input,
	ActionName: jsii.String("s3-deploy-action"),
}))

Actions that don't take an AWS resource will accept an explicit region parameter:

// Actions that don't take an AWS resource will accept an explicit `region` parameter.
var stage iStage
var templatePath artifactPath

stage.AddAction(codepipeline_actions.NewCloudFormationCreateUpdateStackAction(&CloudFormationCreateUpdateStackActionProps{
	TemplatePath: TemplatePath,
	AdminPermissions: jsii.Boolean(false),
	StackName: awscdk.*stack_Of(this).stackName,
	ActionName: jsii.String("cloudformation-create-update"),
	// ...
	Region: jsii.String("us-west-1"),
}))

The Pipeline construct automatically defines a replication bucket for you in the target region, which the pipeline will replicate artifacts to and from. This Bucket will be defined in a support stack named <PipelineStackName>-support-<region>, that will automatically be deployed before the stack containing the pipeline.

If you don't want to use these support stacks, and already have buckets in place to serve as replication buckets, you can supply these at Pipeline definition time using the crossRegionReplicationBuckets parameter. Example:

// Supply replication buckets for the Pipeline instead of using the generated support stack
pipeline := codepipeline.NewPipeline(this, jsii.String("MyFirstPipeline"), &PipelineProps{
	// ...

	CrossRegionReplicationBuckets: map[string]iBucket{
		// note that a physical name of the replication Bucket must be known at synthesis time
		"us-west-1": s3.Bucket_fromBucketAttributes(this, jsii.String("UsWest1ReplicationBucket"), &BucketAttributes{
			"bucketName": jsii.String("my-us-west-1-replication-bucket"),
			// optional KMS key
			"encryptionKey": kms.Key_fromKeyArn(this, jsii.String("UsWest1ReplicationKey"), jsii.String("arn:aws:kms:us-west-1:123456789012:key/1234-5678-9012")),
		}),
	},
})

See the AWS docs here for more information on cross-region CodePipelines.

Creating an encrypted replication bucket

If you're passing a replication bucket created in a different stack, like this:

// Passing a replication bucket created in a different stack.
app := awscdk.NewApp()
replicationStack := awscdk.Newstack(app, jsii.String("ReplicationStack"), &StackProps{
	Env: &Environment{
		Region: jsii.String("us-west-1"),
	},
})
key := kms.NewKey(replicationStack, jsii.String("ReplicationKey"))
replicationBucket := s3.NewBucket(replicationStack, jsii.String("ReplicationBucket"), &BucketProps{
	// like was said above - replication buckets need a set physical name
	BucketName: awscdk.PhysicalName_GENERATE_IF_NEEDED(),
	EncryptionKey: key,
})

// later...
// later...
codepipeline.NewPipeline(replicationStack, jsii.String("Pipeline"), &PipelineProps{
	CrossRegionReplicationBuckets: map[string]iBucket{
		"us-west-1": replicationBucket,
	},
})

When trying to encrypt it (and note that if any of the cross-region actions happen to be cross-account as well, the bucket has to be encrypted - otherwise the pipeline will fail at runtime), you cannot use a key directly - KMS keys don't have physical names, and so you can't reference them across environments.

In this case, you need to use an alias in place of the key when creating the bucket:

// Passing an encrypted replication bucket created in a different stack.
app := awscdk.NewApp()
replicationStack := awscdk.Newstack(app, jsii.String("ReplicationStack"), &StackProps{
	Env: &Environment{
		Region: jsii.String("us-west-1"),
	},
})
key := kms.NewKey(replicationStack, jsii.String("ReplicationKey"))
alias := kms.NewAlias(replicationStack, jsii.String("ReplicationAlias"), &AliasProps{
	// aliasName is required
	AliasName: awscdk.PhysicalName_GENERATE_IF_NEEDED(),
	TargetKey: key,
})
replicationBucket := s3.NewBucket(replicationStack, jsii.String("ReplicationBucket"), &BucketProps{
	BucketName: awscdk.PhysicalName_GENERATE_IF_NEEDED(),
	EncryptionKey: alias,
})

Variables

Variables are key-value pairs that can be used to dynamically configure actions in your pipeline.

There are two types of variables, Action-level variables and Pipeline-level variables. Action-level variables are produced when an action is executed. Pipeline-level variables are defined when the pipeline is created and resolved at pipeline run time. You specify the Pipeline-level variables when the pipeline is created, and you can provide values at the time of the pipeline execution.

Action-level variables

The library supports action-level variables. Each action class that emits variables has a separate variables interface, accessed as a property of the action instance called variables. You instantiate the action class and assign it to a local variable; when you want to use a variable in the configuration of a different action, you access the appropriate property of the interface returned from variables, which represents a single variable. Example:

// MyAction is some action type that produces variables, like EcrSourceAction
myAction := NewMyAction(&myActionProps{
	// ...
	actionName: jsii.String("myAction"),
})
NewOtherAction(&otherActionProps{
	// ...
	config: myAction.variables.myVariable,
	actionName: jsii.String("otherAction"),
})

The namespace name that will be used will be automatically generated by the pipeline construct, based on the stage and action name; you can pass a custom name when creating the action instance:

// MyAction is some action type that produces variables, like EcrSourceAction
myAction := NewMyAction(&myActionProps{
	// ...
	variablesNamespace: jsii.String("MyNamespace"),
	actionName: jsii.String("myAction"),
})

There are also global variables available, not tied to any action; these are accessed through static properties of the GlobalVariables class:

// OtherAction is some action type that produces variables, like EcrSourceAction
// OtherAction is some action type that produces variables, like EcrSourceAction
NewOtherAction(&otherActionProps{
	// ...
	config: codepipeline.GlobalVariables_ExecutionId(),
	actionName: jsii.String("otherAction"),
})

The following is an actual code example.

var sourceAction s3SourceAction
var sourceOutput artifact
var deployBucket bucket


codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Deploy"),
			Actions: []*iAction{
				codepipeline_actions.NewS3DeployAction(&S3DeployActionProps{
					ActionName: jsii.String("DeployAction"),
					// can reference the variables
					ObjectKey: fmt.Sprintf("%v.txt", sourceAction.variables.VersionId),
					Input: sourceOutput,
					Bucket: deployBucket,
				}),
			},
		},
	},
})

Check the documentation of the aws-cdk-lib/aws-codepipeline-actions for details on how to use the variables for each action class.

See the CodePipeline documentation for more details on how to use the variables feature.

Pipeline-level variables

You can add one or more variables at the pipeline level. You can reference this value in the configuration of CodePipeline actions. You can add the variable names, default values, and descriptions when you create the pipeline. Variables are resolved at the time of execution.

Note that using pipeline-level variables in any kind of Source action is not supported. Also, the variables can only be used with pipeline type V2.

var sourceAction s3SourceAction
var sourceOutput artifact
var deployBucket bucket


// Pipeline-level variable
variable := codepipeline.NewVariable(&VariableProps{
	VariableName: jsii.String("bucket-var"),
	Description: jsii.String("description"),
	DefaultValue: jsii.String("sample"),
})

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Variables: []variable{
		variable,
	},
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Deploy"),
			Actions: []*iAction{
				codepipeline_actions.NewS3DeployAction(&S3DeployActionProps{
					ActionName: jsii.String("DeployAction"),
					// can reference the variables
					ObjectKey: fmt.Sprintf("%v.txt", variable.Reference()),
					Input: sourceOutput,
					Bucket: deployBucket,
				}),
			},
		},
	},
})

Or append a variable to an existing pipeline:

var pipeline pipeline


variable := codepipeline.NewVariable(&VariableProps{
	VariableName: jsii.String("bucket-var"),
	Description: jsii.String("description"),
	DefaultValue: jsii.String("sample"),
})
pipeline.AddVariable(variable)

Events

Using a pipeline as an event target

A pipeline can be used as a target for a CloudWatch event rule:

// A pipeline being used as a target for a CloudWatch event rule.
import targets "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var pipeline pipeline


// kick off the pipeline every day
rule := events.NewRule(this, jsii.String("Daily"), &RuleProps{
	Schedule: events.Schedule_Rate(awscdk.Duration_Days(jsii.Number(1))),
})
rule.AddTarget(targets.NewCodePipeline(pipeline))

When a pipeline is used as an event target, the "codepipeline:StartPipelineExecution" permission is granted to the AWS CloudWatch Events service.

Event sources

Pipelines emit CloudWatch events. To define event rules for events emitted by the pipeline, stages or action, use the onXxx methods on the respective construct:

// Define event rules for events emitted by the pipeline
import events "github.com/aws/aws-cdk-go/awscdk"

var myPipeline pipeline
var myStage iStage
var myAction action
var target iRuleTarget

myPipeline.onStateChange(jsii.String("MyPipelineStateChange"), &OnEventOptions{
	Target: target,
})
myStage.OnStateChange(jsii.String("MyStageStateChange"), target)
myAction.OnStateChange(jsii.String("MyActionStateChange"), target)

CodeStar Notifications

To define CodeStar Notification rules for Pipelines, use one of the notifyOnXxx() methods. They are very similar to onXxx() methods for CloudWatch events:

// Define CodeStar Notification rules for Pipelines
import chatbot "github.com/aws/aws-cdk-go/awscdk"

var pipeline pipeline

target := chatbot.NewSlackChannelConfiguration(this, jsii.String("MySlackChannel"), &SlackChannelConfigurationProps{
	SlackChannelConfigurationName: jsii.String("YOUR_CHANNEL_NAME"),
	SlackWorkspaceId: jsii.String("YOUR_SLACK_WORKSPACE_ID"),
	SlackChannelId: jsii.String("YOUR_SLACK_CHANNEL_ID"),
})
rule := pipeline.notifyOnExecutionStateChange(jsii.String("NotifyOnExecutionStateChange"), target)

Trigger

To trigger a pipeline with Git tags or branches, specify the triggers property. The triggers can only be used with pipeline type V2.

Push filter

Pipelines can be started based on push events. You can specify the pushFilter property to filter the push events. The pushFilter can specify Git tags.

In the case of Git tags, your pipeline starts when a Git tag is pushed. You can filter with glob patterns. The tagsExcludes takes priority over the tagsIncludes.

var sourceAction codeStarConnectionsSourceAction
var buildAction codeBuildAction


codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
	Triggers: []triggerProps{
		&triggerProps{
			ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
			GitConfiguration: &GitConfiguration{
				SourceAction: *SourceAction,
				PushFilter: []gitPushFilter{
					&gitPushFilter{
						TagsExcludes: []*string{
							jsii.String("exclude1"),
							jsii.String("exclude2"),
						},
						TagsIncludes: []*string{
							jsii.String("include*"),
						},
					},
				},
			},
		},
	},
})

Pull request filter

Pipelines can be started based on pull request events. You can specify the pullRequestFilter property to filter the pull request events. The pullRequestFilter can specify branches, file paths, and event types.

In the case of branches, your pipeline starts when a pull request event occurs on the specified branches. You can filter with glob patterns. The branchesExcludes takes priority over the branchesIncludes.

var sourceAction codeStarConnectionsSourceAction
var buildAction codeBuildAction


codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
	Triggers: []triggerProps{
		&triggerProps{
			ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
			GitConfiguration: &GitConfiguration{
				SourceAction: *SourceAction,
				PullRequestFilter: []gitPullRequestFilter{
					&gitPullRequestFilter{
						BranchesExcludes: []*string{
							jsii.String("exclude1"),
							jsii.String("exclude2"),
						},
						BranchesIncludes: []*string{
							jsii.String("include*"),
						},
					},
				},
			},
		},
	},
})

File paths can also be specified along with the branches to start the pipeline. You can filter with glob patterns. The filePathsExcludes takes priority over the filePathsIncludes.

var sourceAction codeStarConnectionsSourceAction
var buildAction codeBuildAction


codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
	Triggers: []triggerProps{
		&triggerProps{
			ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
			GitConfiguration: &GitConfiguration{
				SourceAction: *SourceAction,
				PullRequestFilter: []gitPullRequestFilter{
					&gitPullRequestFilter{
						BranchesExcludes: []*string{
							jsii.String("exclude1"),
							jsii.String("exclude2"),
						},
						BranchesIncludes: []*string{
							jsii.String("include1"),
							jsii.String("include2"),
						},
						FilePathsExcludes: []*string{
							jsii.String("/path/to/exclude1"),
							jsii.String("/path/to/exclude2"),
						},
						FilePathsIncludes: []*string{
							jsii.String("/path/to/include1"),
							jsii.String("/path/to/include1"),
						},
					},
				},
			},
		},
	},
})

To filter types of pull request events for triggers, you can specify the events property.

var sourceAction codeStarConnectionsSourceAction
var buildAction codeBuildAction


codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
	Triggers: []triggerProps{
		&triggerProps{
			ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
			GitConfiguration: &GitConfiguration{
				SourceAction: *SourceAction,
				PullRequestFilter: []gitPullRequestFilter{
					&gitPullRequestFilter{
						BranchesExcludes: []*string{
							jsii.String("exclude1"),
							jsii.String("exclude2"),
						},
						BranchesIncludes: []*string{
							jsii.String("include1"),
							jsii.String("include2"),
						},
						Events: []gitPullRequestEvent{
							codepipeline.*gitPullRequestEvent_OPEN,
							codepipeline.*gitPullRequestEvent_CLOSED,
						},
					},
				},
			},
		},
	},
})

Append a trigger to an existing pipeline

You can append a trigger to an existing pipeline:

var pipeline pipeline
var sourceAction codeStarConnectionsSourceAction


pipeline.AddTrigger(&TriggerProps{
	ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
	GitConfiguration: &GitConfiguration{
		SourceAction: *SourceAction,
		PushFilter: []gitPushFilter{
			&gitPushFilter{
				TagsExcludes: []*string{
					jsii.String("exclude1"),
					jsii.String("exclude2"),
				},
				TagsIncludes: []*string{
					jsii.String("include*"),
				},
			},
		},
	},
})

Execution mode

To control the concurrency behavior when multiple executions of a pipeline are started, you can use the executionMode property.

The execution mode can only be used with pipeline type V2.

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	ExecutionMode: codepipeline.ExecutionMode_PARALLEL,
})

Migrating a pipeline type from V1 to V2

To migrate your pipeline type from V1 to V2, you just need to update the pipelineType property to PipelineType.V2. This migration does not cause replacement of your pipeline.

When the @aws-cdk/aws-codepipeline:defaultPipelineTypeToV2 feature flag is set to true (default for new projects), the V2 type is selected by default if you do not specify a value for pipelineType property. Otherwise, the V1 type is selected.

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
})

See the CodePipeline documentation for more details on the differences between each type.

Documentation

Index

• func CfnCustomActionType_CFN_RESOURCE_TYPE_NAME() *string
• func CfnCustomActionType_IsCfnElement(x interface{}) *bool
• func CfnCustomActionType_IsCfnResource(x interface{}) *bool
• func CfnCustomActionType_IsConstruct(x interface{}) *bool
• func CfnPipeline_CFN_RESOURCE_TYPE_NAME() *string
• func CfnPipeline_IsCfnElement(x interface{}) *bool
• func CfnPipeline_IsCfnResource(x interface{}) *bool
• func CfnPipeline_IsConstruct(x interface{}) *bool
• func CfnWebhook_CFN_RESOURCE_TYPE_NAME() *string
• func CfnWebhook_IsCfnElement(x interface{}) *bool
• func CfnWebhook_IsCfnResource(x interface{}) *bool
• func CfnWebhook_IsConstruct(x interface{}) *bool
• func CustomActionRegistration_IsConstruct(x interface{}) *bool
• func GlobalVariables_ExecutionId() *string
• func NewAction_Override(a Action)
• func NewArtifactPath_Override(a ArtifactPath, artifact Artifact, fileName *string)
• func NewArtifact_Override(a Artifact, artifactName *string)
• func NewCfnCustomActionType_Override(c CfnCustomActionType, scope constructs.Construct, id *string, ...)
• func NewCfnPipeline_Override(c CfnPipeline, scope constructs.Construct, id *string, props *CfnPipelineProps)
• func NewCfnWebhook_Override(c CfnWebhook, scope constructs.Construct, id *string, props *CfnWebhookProps)
• func NewCustomActionRegistration_Override(c CustomActionRegistration, scope constructs.Construct, id *string, ...)
• func NewGlobalVariables_Override(g GlobalVariables)
• func NewPipeline_Override(p Pipeline, scope constructs.Construct, id *string, props *PipelineProps)
• func NewTrigger_Override(t Trigger, props *TriggerProps)
• func NewVariable_Override(v Variable, props *VariableProps)
• func Pipeline_IsConstruct(x interface{}) *bool
• func Pipeline_IsOwnedResource(construct constructs.IConstruct) *bool
• func Pipeline_IsResource(construct constructs.IConstruct) *bool
• type Action
• type ActionArtifactBounds
• type ActionBindOptions
• type ActionCategory
• type ActionConfig
• type ActionProperties
• type Artifact
  • func Artifact_Artifact(name *string) Artifact
  • func NewArtifact(artifactName *string) Artifact
• type ArtifactPath
  • func ArtifactPath_ArtifactPath(artifactName *string, fileName *string) ArtifactPath
  • func NewArtifactPath(artifact Artifact, fileName *string) ArtifactPath
• type CfnCustomActionType
  • func NewCfnCustomActionType(scope constructs.Construct, id *string, props *CfnCustomActionTypeProps) CfnCustomActionType
• type CfnCustomActionTypeProps
• type CfnCustomActionType_ArtifactDetailsProperty
• type CfnCustomActionType_ConfigurationPropertiesProperty
• type CfnCustomActionType_SettingsProperty
• type CfnPipeline
  • func NewCfnPipeline(scope constructs.Construct, id *string, props *CfnPipelineProps) CfnPipeline
• type CfnPipelineProps
• type CfnPipeline_ActionDeclarationProperty
• type CfnPipeline_ActionTypeIdProperty
• type CfnPipeline_ArtifactStoreMapProperty
• type CfnPipeline_ArtifactStoreProperty
• type CfnPipeline_BeforeEntryConditionsProperty
• type CfnPipeline_BlockerDeclarationProperty
• type CfnPipeline_ConditionProperty
• type CfnPipeline_EncryptionKeyProperty
• type CfnPipeline_FailureConditionsProperty
• type CfnPipeline_GitBranchFilterCriteriaProperty
• type CfnPipeline_GitConfigurationProperty
• type CfnPipeline_GitFilePathFilterCriteriaProperty
• type CfnPipeline_GitPullRequestFilterProperty
• type CfnPipeline_GitPushFilterProperty
• type CfnPipeline_GitTagFilterCriteriaProperty
• type CfnPipeline_InputArtifactProperty
• type CfnPipeline_OutputArtifactProperty
• type CfnPipeline_PipelineTriggerDeclarationProperty
• type CfnPipeline_RuleDeclarationProperty
• type CfnPipeline_RuleTypeIdProperty
• type CfnPipeline_StageDeclarationProperty
• type CfnPipeline_StageTransitionProperty
• type CfnPipeline_SuccessConditionsProperty
• type CfnPipeline_VariableDeclarationProperty
• type CfnWebhook
  • func NewCfnWebhook(scope constructs.Construct, id *string, props *CfnWebhookProps) CfnWebhook
• type CfnWebhookProps
• type CfnWebhook_WebhookAuthConfigurationProperty
• type CfnWebhook_WebhookFilterRuleProperty
• type CommonActionProps
• type CommonAwsActionProps
• type CrossRegionSupport
• type CustomActionProperty
• type CustomActionRegistration
  • func NewCustomActionRegistration(scope constructs.Construct, id *string, props *CustomActionRegistrationProps) CustomActionRegistration
• type CustomActionRegistrationProps
• type ExecutionMode
• type GitConfiguration
• type GitPullRequestEvent
• type GitPullRequestFilter
• type GitPushFilter
• type GlobalVariables
  • func NewGlobalVariables() GlobalVariables
• type IAction
• type IPipeline
  • func Pipeline_FromPipelineArn(scope constructs.Construct, id *string, pipelineArn *string) IPipeline
• type IStage
• type Pipeline
  • func NewPipeline(scope constructs.Construct, id *string, props *PipelineProps) Pipeline
• type PipelineNotificationEvents
• type PipelineNotifyOnOptions
• type PipelineProps
• type PipelineType
• type ProviderType
• type StageOptions
• type StagePlacement
• type StageProps
• type Trigger
  • func NewTrigger(props *TriggerProps) Trigger
• type TriggerProps
• type Variable
  • func NewVariable(props *VariableProps) Variable
• type VariableProps

Functions

func CfnCustomActionType_CFN_RESOURCE_TYPE_NAME

func CfnCustomActionType_CFN_RESOURCE_TYPE_NAME() *string

func CfnCustomActionType_IsCfnElement

func CfnCustomActionType_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnCustomActionType_IsCfnResource

func CfnCustomActionType_IsCfnResource(x interface{}) *bool

Check whether the given object is a CfnResource.

func CfnCustomActionType_IsConstruct

func CfnCustomActionType_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnPipeline_CFN_RESOURCE_TYPE_NAME

func CfnPipeline_CFN_RESOURCE_TYPE_NAME() *string

func CfnPipeline_IsCfnElement

func CfnPipeline_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnPipeline_IsCfnResource

func CfnPipeline_IsCfnResource(x interface{}) *bool

Check whether the given object is a CfnResource.

func CfnPipeline_IsConstruct

func CfnPipeline_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CfnWebhook_CFN_RESOURCE_TYPE_NAME

func CfnWebhook_CFN_RESOURCE_TYPE_NAME() *string

func CfnWebhook_IsCfnElement

func CfnWebhook_IsCfnElement(x interface{}) *bool

Returns `true` if a construct is a stack element (i.e. part of the synthesized cloudformation template).

Uses duck-typing instead of `instanceof` to allow stack elements from different versions of this library to be included in the same stack.

Returns: The construct as a stack element or undefined if it is not a stack element.

func CfnWebhook_IsCfnResource

func CfnWebhook_IsCfnResource(x interface{}) *bool

Check whether the given object is a CfnResource.

func CfnWebhook_IsConstruct

func CfnWebhook_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func CustomActionRegistration_IsConstruct

func CustomActionRegistration_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func GlobalVariables_ExecutionId

func GlobalVariables_ExecutionId() *string

func NewAction_Override

func NewAction_Override(a Action)

func NewArtifactPath_Override

func NewArtifactPath_Override(a ArtifactPath, artifact Artifact, fileName *string)

func NewArtifact_Override

func NewArtifact_Override(a Artifact, artifactName *string)

func NewCfnCustomActionType_Override

func NewCfnCustomActionType_Override(c CfnCustomActionType, scope constructs.Construct, id *string, props *CfnCustomActionTypeProps)

func NewCfnPipeline_Override

func NewCfnPipeline_Override(c CfnPipeline, scope constructs.Construct, id *string, props *CfnPipelineProps)

func NewCfnWebhook_Override

func NewCfnWebhook_Override(c CfnWebhook, scope constructs.Construct, id *string, props *CfnWebhookProps)

func NewCustomActionRegistration_Override

func NewCustomActionRegistration_Override(c CustomActionRegistration, scope constructs.Construct, id *string, props *CustomActionRegistrationProps)

func NewGlobalVariables_Override

func NewGlobalVariables_Override(g GlobalVariables)

func NewPipeline_Override

func NewPipeline_Override(p Pipeline, scope constructs.Construct, id *string, props *PipelineProps)

func NewTrigger_Override

func NewTrigger_Override(t Trigger, props *TriggerProps)

func NewVariable_Override

func NewVariable_Override(v Variable, props *VariableProps)

func Pipeline_IsConstruct

func Pipeline_IsConstruct(x interface{}) *bool

Checks if `x` is a construct.

Use this method instead of `instanceof` to properly detect `Construct` instances, even when the construct library is symlinked.

Explanation: in JavaScript, multiple copies of the `constructs` library on disk are seen as independent, completely different libraries. As a consequence, the class `Construct` in each copy of the `constructs` library is seen as a different class, and an instance of one class will not test as `instanceof` the other class. `npm install` will not create installations like this, but users may manually symlink construct libraries together or use a monorepo tool: in those cases, multiple copies of the `constructs` library can be accidentally installed, and `instanceof` will behave unpredictably. It is safest to avoid using `instanceof`, and using this type-testing method instead.

Returns: true if `x` is an object created from a class which extends `Construct`.

func Pipeline_IsOwnedResource

func Pipeline_IsOwnedResource(construct constructs.IConstruct) *bool

Returns true if the construct was created by CDK, and false otherwise.

func Pipeline_IsResource

func Pipeline_IsResource(construct constructs.IConstruct) *bool

Check whether the given construct is a Resource.

Types

type Action

type Action interface {
	IAction
	// The simple properties of the Action, like its Owner, name, etc.
	//
	// Note that this accessor will be called before the `bind` callback.
	ActionProperties() *ActionProperties
	// This is a renamed version of the `IAction.actionProperties` property.
	ProvidedActionProperties() *ActionProperties
	// The callback invoked when this Action is added to a Pipeline.
	Bind(scope constructs.Construct, stage IStage, options *ActionBindOptions) *ActionConfig
	// This is a renamed version of the `IAction.bind` method.
	Bound(scope constructs.Construct, stage IStage, options *ActionBindOptions) *ActionConfig
	// Creates an Event that will be triggered whenever the state of this Action changes.
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	VariableExpression(variableName *string) *string
}

Low-level class for generic CodePipeline Actions implementing the `IAction` interface.

Contains some common logic that can be re-used by all `IAction` implementations. If you're writing your own Action class, feel free to extend this class.

type ActionArtifactBounds

type ActionArtifactBounds struct {
	MaxInputs  *float64 `field:"required" json:"maxInputs" yaml:"maxInputs"`
	MaxOutputs *float64 `field:"required" json:"maxOutputs" yaml:"maxOutputs"`
	MinInputs  *float64 `field:"required" json:"minInputs" yaml:"minInputs"`
	MinOutputs *float64 `field:"required" json:"minOutputs" yaml:"minOutputs"`
}

Specifies the constraints on the number of input and output artifacts an action can have.

The constraints for each action type are documented on the [Pipeline Structure Reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html) page.

Example:

// MyAction is some action type that produces variables, like EcrSourceAction
myAction := NewMyAction(&myActionProps{
	// ...
	actionName: jsii.String("myAction"),
})
NewOtherAction(&otherActionProps{
	// ...
	config: myAction.variables.myVariable,
	actionName: jsii.String("otherAction"),
})

type ActionBindOptions

type ActionBindOptions struct {
	Bucket awss3.IBucket `field:"required" json:"bucket" yaml:"bucket"`
	Role   awsiam.IRole  `field:"required" json:"role" yaml:"role"`
}

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var role role

actionBindOptions := &ActionBindOptions{
	Bucket: bucket,
	Role: role,
}

type ActionCategory

type ActionCategory string

Example:

// MyAction is some action type that produces variables, like EcrSourceAction
myAction := NewMyAction(&myActionProps{
	// ...
	actionName: jsii.String("myAction"),
})
NewOtherAction(&otherActionProps{
	// ...
	config: myAction.variables.myVariable,
	actionName: jsii.String("otherAction"),
})

const (
	ActionCategory_SOURCE   ActionCategory = "SOURCE"
	ActionCategory_BUILD    ActionCategory = "BUILD"
	ActionCategory_TEST     ActionCategory = "TEST"
	ActionCategory_APPROVAL ActionCategory = "APPROVAL"
	ActionCategory_DEPLOY   ActionCategory = "DEPLOY"
	ActionCategory_INVOKE   ActionCategory = "INVOKE"
)

type ActionConfig

type ActionConfig struct {
	Configuration interface{} `field:"optional" json:"configuration" yaml:"configuration"`
}

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

actionConfig := &ActionConfig{
	Configuration: configuration,
}

type ActionProperties

type ActionProperties struct {
	ActionName     *string               `field:"required" json:"actionName" yaml:"actionName"`
	ArtifactBounds *ActionArtifactBounds `field:"required" json:"artifactBounds" yaml:"artifactBounds"`
	// The category of the action.
	//
	// The category defines which action type the owner
	// (the entity that performs the action) performs.
	Category ActionCategory `field:"required" json:"category" yaml:"category"`
	// The service provider that the action calls.
	Provider *string `field:"required" json:"provider" yaml:"provider"`
	// The account the Action is supposed to live in.
	//
	// For Actions backed by resources,
	// this is inferred from the Stack `resource` is part of.
	// However, some Actions, like the CloudFormation ones,
	// are not backed by any resource, and they still might want to be cross-account.
	// In general, a concrete Action class should specify either `resource`,
	// or `account` - but not both.
	Account *string     `field:"optional" json:"account" yaml:"account"`
	Inputs  *[]Artifact `field:"optional" json:"inputs" yaml:"inputs"`
	Outputs *[]Artifact `field:"optional" json:"outputs" yaml:"outputs"`
	Owner   *string     `field:"optional" json:"owner" yaml:"owner"`
	// The AWS region the given Action resides in.
	//
	// Note that a cross-region Pipeline requires replication buckets to function correctly.
	// You can provide their names with the `PipelineProps#crossRegionReplicationBuckets` property.
	// If you don't, the CodePipeline Construct will create new Stacks in your CDK app containing those buckets,
	// that you will need to `cdk deploy` before deploying the main, Pipeline-containing Stack.
	// Default: the Action resides in the same region as the Pipeline.
	//
	Region *string `field:"optional" json:"region" yaml:"region"`
	// The optional resource that is backing this Action.
	//
	// This is used for automatically handling Actions backed by
	// resources from a different account and/or region.
	Resource awscdk.IResource `field:"optional" json:"resource" yaml:"resource"`
	Role     awsiam.IRole     `field:"optional" json:"role" yaml:"role"`
	// The order in which AWS CodePipeline runs this action. For more information, see the AWS CodePipeline User Guide.
	//
	// https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements
	RunOrder *float64 `field:"optional" json:"runOrder" yaml:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	// Default: - a name will be generated, based on the stage and action names.
	//
	VariablesNamespace *string `field:"optional" json:"variablesNamespace" yaml:"variablesNamespace"`
	Version            *string `field:"optional" json:"version" yaml:"version"`
}

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var artifact artifact
var resource resource
var role role

actionProperties := &ActionProperties{
	ActionName: jsii.String("actionName"),
	ArtifactBounds: &ActionArtifactBounds{
		MaxInputs: jsii.Number(123),
		MaxOutputs: jsii.Number(123),
		MinInputs: jsii.Number(123),
		MinOutputs: jsii.Number(123),
	},
	Category: awscdk.Aws_codepipeline.ActionCategory_SOURCE,
	Provider: jsii.String("provider"),

	// the properties below are optional
	Account: jsii.String("account"),
	Inputs: []*artifact{
		artifact,
	},
	Outputs: []*artifact{
		artifact,
	},
	Owner: jsii.String("owner"),
	Region: jsii.String("region"),
	Resource: resource,
	Role: role,
	RunOrder: jsii.Number(123),
	VariablesNamespace: jsii.String("variablesNamespace"),
	Version: jsii.String("version"),
}

type Artifact

type Artifact interface {
	ArtifactName() *string
	// The artifact attribute for the name of the S3 bucket where the artifact is stored.
	BucketName() *string
	// The artifact attribute for The name of the .zip file that contains the artifact that is generated by AWS CodePipeline, such as 1ABCyZZ.zip.
	ObjectKey() *string
	// Returns the location of the .zip file in S3 that this Artifact represents. Used by Lambda's `CfnParametersCode` when being deployed in a CodePipeline.
	S3Location() *awss3.Location
	// The artifact attribute of the Amazon Simple Storage Service (Amazon S3) URL of the artifact, such as https://s3-us-west-2.amazonaws.com/artifactstorebucket-yivczw8jma0c/test/TemplateSo/1ABCyZZ.zip.
	Url() *string
	// Returns an ArtifactPath for a file within this artifact.
	//
	// CfnOutput is in the form "<artifact-name>::<file-name>".
	AtPath(fileName *string) ArtifactPath
	// Retrieve the metadata stored in this artifact under the given key.
	//
	// If there is no metadata stored under the given key,
	// null will be returned.
	GetMetadata(key *string) interface{}
	// Returns a token for a value inside a JSON file within this artifact.
	GetParam(jsonFile *string, keyName *string) *string
	// Add arbitrary extra payload to the artifact under a given key.
	//
	// This can be used by CodePipeline actions to communicate data between themselves.
	// If metadata was already present under the given key,
	// it will be overwritten with the new value.
	SetMetadata(key *string, value interface{})
	ToString() *string
}

An output artifact of an action.

Artifacts can be used as input by some actions.

Example:

// later:
var project pipelineProject
lambdaInvokeAction := codepipeline_actions.NewLambdaInvokeAction(&LambdaInvokeActionProps{
	ActionName: jsii.String("Lambda"),
	Lambda: lambda.NewFunction(this, jsii.String("Func"), &FunctionProps{
		Runtime: lambda.Runtime_NODEJS_LATEST(),
		Handler: jsii.String("index.handler"),
		Code: lambda.Code_FromInline(jsii.String(`
		        const { CodePipeline } = require('@aws-sdk/client-codepipeline');

		        exports.handler = async function(event, context) {
		            const codepipeline = new AWS.CodePipeline();
		            await codepipeline.putJobSuccessResult({
		                jobId: event['CodePipeline.job'].id,
		                outputVariables: {
		                    MY_VAR: "some value",
		                },
		            });
		        }
		    `)),
	}),
	VariablesNamespace: jsii.String("MyNamespace"),
})
sourceOutput := codepipeline.NewArtifact()
codepipeline_actions.NewCodeBuildAction(&CodeBuildActionProps{
	ActionName: jsii.String("CodeBuild"),
	Project: Project,
	Input: sourceOutput,
	EnvironmentVariables: map[string]buildEnvironmentVariable{
		"MyVar": &buildEnvironmentVariable{
			"value": lambdaInvokeAction.variable(jsii.String("MY_VAR")),
		},
	},
})

func Artifact_Artifact

func Artifact_Artifact(name *string) Artifact

A static factory method used to create instances of the Artifact class.

Mainly meant to be used from `decdk`.

func NewArtifact

func NewArtifact(artifactName *string) Artifact

type ArtifactPath

type ArtifactPath interface {
	Artifact() Artifact
	FileName() *string
	Location() *string
}

A specific file within an output artifact.

The most common use case for this is specifying the template file for a CloudFormation action.

Example:

// Source stage: read from repository
repo := codecommit.NewRepository(stack, jsii.String("TemplateRepo"), &RepositoryProps{
	RepositoryName: jsii.String("template-repo"),
})
sourceOutput := codepipeline.NewArtifact(jsii.String("SourceArtifact"))
source := cpactions.NewCodeCommitSourceAction(&CodeCommitSourceActionProps{
	ActionName: jsii.String("Source"),
	Repository: repo,
	Output: sourceOutput,
	Trigger: cpactions.CodeCommitTrigger_POLL,
})
sourceStage := map[string]interface{}{
	"stageName": jsii.String("Source"),
	"actions": []CodeCommitSourceAction{
		source,
	},
}

// Deployment stage: create and deploy changeset with manual approval
stackName := "OurStack"
changeSetName := "StagedChangeSet"

prodStage := map[string]interface{}{
	"stageName": jsii.String("Deploy"),
	"actions": []interface{}{
		cpactions.NewCloudFormationCreateReplaceChangeSetAction(&CloudFormationCreateReplaceChangeSetActionProps{
			"actionName": jsii.String("PrepareChanges"),
			"stackName": jsii.String(stackName),
			"changeSetName": jsii.String(changeSetName),
			"adminPermissions": jsii.Boolean(true),
			"templatePath": sourceOutput.atPath(jsii.String("template.yaml")),
			"runOrder": jsii.Number(1),
		}),
		cpactions.NewManualApprovalAction(&ManualApprovalActionProps{
			"actionName": jsii.String("ApproveChanges"),
			"runOrder": jsii.Number(2),
		}),
		cpactions.NewCloudFormationExecuteChangeSetAction(&CloudFormationExecuteChangeSetActionProps{
			"actionName": jsii.String("ExecuteChanges"),
			"stackName": jsii.String(stackName),
			"changeSetName": jsii.String(changeSetName),
			"runOrder": jsii.Number(3),
		}),
	},
}

codepipeline.NewPipeline(stack, jsii.String("Pipeline"), &PipelineProps{
	CrossAccountKeys: jsii.Boolean(true),
	Stages: []stageProps{
		sourceStage,
		prodStage,
	},
})

func ArtifactPath_ArtifactPath

func ArtifactPath_ArtifactPath(artifactName *string, fileName *string) ArtifactPath

func NewArtifactPath

func NewArtifactPath(artifact Artifact, fileName *string) ArtifactPath

type CfnCustomActionType

type CfnCustomActionType interface {
	awscdk.CfnResource
	awscdk.IInspectable
	awscdk.ITaggable
	AttrId() *string
	// The category of the custom action, such as a build action or a test action.
	Category() *string
	SetCategory(val *string)
	// Options for this resource, such as condition, update policy etc.
	CfnOptions() awscdk.ICfnResourceOptions
	CfnProperties() *map[string]interface{}
	// AWS resource type.
	CfnResourceType() *string
	// The configuration properties for the custom action.
	ConfigurationProperties() interface{}
	SetConfigurationProperties(val interface{})
	// Returns: the stack trace of the point where this Resource was created from, sourced
	// from the +metadata+ entry typed +aws:cdk:logicalId+, and with the bottom-most
	// node +internal+ entries filtered.
	CreationStack() *[]*string
	// The details of the input artifact for the action, such as its commit ID.
	InputArtifactDetails() interface{}
	SetInputArtifactDetails(val interface{})
	// The logical ID for this CloudFormation stack element.
	//
	// The logical ID of the element
	// is calculated from the path of the resource node in the construct tree.
	//
	// To override this value, use `overrideLogicalId(newLogicalId)`.
	//
	// Returns: the logical ID as a stringified token. This value will only get
	// resolved during synthesis.
	LogicalId() *string
	// The tree node.
	Node() constructs.Node
	// The details of the output artifact of the action, such as its commit ID.
	OutputArtifactDetails() interface{}
	SetOutputArtifactDetails(val interface{})
	// The provider of the service used in the custom action, such as CodeDeploy.
	Provider() *string
	SetProvider(val *string)
	// Return a string that will be resolved to a CloudFormation `{ Ref }` for this element.
	//
	// If, by any chance, the intrinsic reference of a resource is not a string, you could
	// coerce it to an IResolvable through `Lazy.any({ produce: resource.ref })`.
	Ref() *string
	// URLs that provide users information about this custom action.
	Settings() interface{}
	SetSettings(val interface{})
	// The stack in which this element is defined.
	//
	// CfnElements must be defined within a stack scope (directly or indirectly).
	Stack() awscdk.Stack
	// Tag Manager which manages the tags for this resource.
	Tags() awscdk.TagManager
	// The tags for the custom action.
	TagsRaw() *[]*awscdk.CfnTag
	SetTagsRaw(val *[]*awscdk.CfnTag)
	// Deprecated.
	// Deprecated: use `updatedProperties`
	//
	// Return properties modified after initiation
	//
	// Resources that expose mutable properties should override this function to
	// collect and return the properties object for this resource.
	UpdatedProperites() *map[string]interface{}
	// Return properties modified after initiation.
	//
	// Resources that expose mutable properties should override this function to
	// collect and return the properties object for this resource.
	UpdatedProperties() *map[string]interface{}
	// The version identifier of the custom action.
	Version() *string
	SetVersion(val *string)
	// Syntactic sugar for `addOverride(path, undefined)`.
	AddDeletionOverride(path *string)
	// Indicates that this resource depends on another resource and cannot be provisioned unless the other resource has been successfully provisioned.
	//
	// This can be used for resources across stacks (or nested stack) boundaries
	// and the dependency will automatically be transferred to the relevant scope.
	AddDependency(target awscdk.CfnResource)
	// Indicates that this resource depends on another resource and cannot be provisioned unless the other resource has been successfully provisioned.
	// Deprecated: use addDependency.
	AddDependsOn(target awscdk.CfnResource)
	// Add a value to the CloudFormation Resource Metadata.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html
	//
	// Note that this is a different set of metadata from CDK node metadata; this
	// metadata ends up in the stack template under the resource, whereas CDK
	// node metadata ends up in the Cloud Assembly.
	//
	AddMetadata(key *string, value interface{})
	// Adds an override to the synthesized CloudFormation resource.
	//
	// To add a
	// property override, either use `addPropertyOverride` or prefix `path` with
	// "Properties." (i.e. `Properties.TopicName`).
	//
	// If the override is nested, separate each nested level using a dot (.) in the path parameter.
	// If there is an array as part of the nesting, specify the index in the path.
	//
	// To include a literal `.` in the property name, prefix with a `\`. In most
	// programming languages you will need to write this as `"\\."` because the
	// `\` itself will need to be escaped.
	//
	// For example,
	// “`typescript
	// cfnResource.addOverride('Properties.GlobalSecondaryIndexes.0.Projection.NonKeyAttributes', ['myattribute']);
	// cfnResource.addOverride('Properties.GlobalSecondaryIndexes.1.ProjectionType', 'INCLUDE');
	// “`
	// would add the overrides
	// “`json
	// "Properties": {
	//   "GlobalSecondaryIndexes": [
	//     {
	//       "Projection": {
	//         "NonKeyAttributes": [ "myattribute" ]
	//         ...
	//       }
	//       ...
	//     },
	//     {
	//       "ProjectionType": "INCLUDE"
	//       ...
	//     },
	//   ]
	//   ...
	// }
	// “`
	//
	// The `value` argument to `addOverride` will not be processed or translated
	// in any way. Pass raw JSON values in here with the correct capitalization
	// for CloudFormation. If you pass CDK classes or structs, they will be
	// rendered with lowercased key names, and CloudFormation will reject the
	// template.
	AddOverride(path *string, value interface{})
	// Adds an override that deletes the value of a property from the resource definition.
	AddPropertyDeletionOverride(propertyPath *string)
	// Adds an override to a resource property.
	//
	// Syntactic sugar for `addOverride("Properties.<...>", value)`.
	AddPropertyOverride(propertyPath *string, value interface{})
	// Sets the deletion policy of the resource based on the removal policy specified.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`). In some
	// cases, a snapshot can be taken of the resource prior to deletion
	// (`RemovalPolicy.SNAPSHOT`). A list of resources that support this policy
	// can be found in the following link:.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html#aws-attribute-deletionpolicy-options
	//
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy, options *awscdk.RemovalPolicyOptions)
	// Returns a token for an runtime attribute of this resource.
	//
	// Ideally, use generated attribute accessors (e.g. `resource.arn`), but this can be used for future compatibility
	// in case there is no generated attribute.
	GetAtt(attributeName *string, typeHint awscdk.ResolutionTypeHint) awscdk.Reference
	// Retrieve a value value from the CloudFormation Resource Metadata.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html
	//
	// Note that this is a different set of metadata from CDK node metadata; this
	// metadata ends up in the stack template under the resource, whereas CDK
	// node metadata ends up in the Cloud Assembly.
	//
	GetMetadata(key *string) interface{}
	// Examines the CloudFormation resource and discloses attributes.
	Inspect(inspector awscdk.TreeInspector)
	// Retrieves an array of resources this resource depends on.
	//
	// This assembles dependencies on resources across stacks (including nested stacks)
	// automatically.
	ObtainDependencies() *[]interface{}
	// Get a shallow copy of dependencies between this resource and other resources in the same stack.
	ObtainResourceDependencies() *[]awscdk.CfnResource
	// Overrides the auto-generated logical ID with a specific ID.
	OverrideLogicalId(newLogicalId *string)
	// Indicates that this resource no longer depends on another resource.
	//
	// This can be used for resources across stacks (including nested stacks)
	// and the dependency will automatically be removed from the relevant scope.
	RemoveDependency(target awscdk.CfnResource)
	RenderProperties(props *map[string]interface{}) *map[string]interface{}
	// Replaces one dependency with another.
	ReplaceDependency(target awscdk.CfnResource, newTarget awscdk.CfnResource)
	// Can be overridden by subclasses to determine if this resource will be rendered into the cloudformation template.
	//
	// Returns: `true` if the resource should be included or `false` is the resource
	// should be omitted.
	ShouldSynthesize() *bool
	// Returns a string representation of this construct.
	//
	// Returns: a string representation of this resource.
	ToString() *string
	ValidateProperties(_properties interface{})
}

The `AWS::CodePipeline::CustomActionType` resource creates a custom action for activities that aren't included in the CodePipeline default actions, such as running an internally developed build process or a test suite.

You can use these custom actions in the stage of a pipeline. For more information, see [Create and Add a Custom Action in AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/how-to-create-custom-action.html) in the *AWS CodePipeline User Guide* .

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

cfnCustomActionType := awscdk.Aws_codepipeline.NewCfnCustomActionType(this, jsii.String("MyCfnCustomActionType"), &CfnCustomActionTypeProps{
	Category: jsii.String("category"),
	InputArtifactDetails: &ArtifactDetailsProperty{
		MaximumCount: jsii.Number(123),
		MinimumCount: jsii.Number(123),
	},
	OutputArtifactDetails: &ArtifactDetailsProperty{
		MaximumCount: jsii.Number(123),
		MinimumCount: jsii.Number(123),
	},
	Provider: jsii.String("provider"),
	Version: jsii.String("version"),

	// the properties below are optional
	ConfigurationProperties: []interface{}{
		&ConfigurationPropertiesProperty{
			Key: jsii.Boolean(false),
			Name: jsii.String("name"),
			Required: jsii.Boolean(false),
			Secret: jsii.Boolean(false),

			// the properties below are optional
			Description: jsii.String("description"),
			Queryable: jsii.Boolean(false),
			Type: jsii.String("type"),
		},
	},
	Settings: &SettingsProperty{
		EntityUrlTemplate: jsii.String("entityUrlTemplate"),
		ExecutionUrlTemplate: jsii.String("executionUrlTemplate"),
		RevisionUrlTemplate: jsii.String("revisionUrlTemplate"),
		ThirdPartyConfigurationUrl: jsii.String("thirdPartyConfigurationUrl"),
	},
	Tags: []cfnTag{
		&cfnTag{
			Key: jsii.String("key"),
			Value: jsii.String("value"),
		},
	},
})

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html

func NewCfnCustomActionType

func NewCfnCustomActionType(scope constructs.Construct, id *string, props *CfnCustomActionTypeProps) CfnCustomActionType

type CfnCustomActionTypeProps

type CfnCustomActionTypeProps struct {
	// The category of the custom action, such as a build action or a test action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html#cfn-codepipeline-customactiontype-category
	//
	Category *string `field:"required" json:"category" yaml:"category"`
	// The details of the input artifact for the action, such as its commit ID.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html#cfn-codepipeline-customactiontype-inputartifactdetails
	//
	InputArtifactDetails interface{} `field:"required" json:"inputArtifactDetails" yaml:"inputArtifactDetails"`
	// The details of the output artifact of the action, such as its commit ID.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html#cfn-codepipeline-customactiontype-outputartifactdetails
	//
	OutputArtifactDetails interface{} `field:"required" json:"outputArtifactDetails" yaml:"outputArtifactDetails"`
	// The provider of the service used in the custom action, such as CodeDeploy.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html#cfn-codepipeline-customactiontype-provider
	//
	Provider *string `field:"required" json:"provider" yaml:"provider"`
	// The version identifier of the custom action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html#cfn-codepipeline-customactiontype-version
	//
	Version *string `field:"required" json:"version" yaml:"version"`
	// The configuration properties for the custom action.
	//
	// > You can refer to a name in the configuration properties of the custom action within the URL templates by following the format of {Config:name}, as long as the configuration property is both required and not secret. For more information, see [Create a Custom Action for a Pipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/how-to-create-custom-action.html) .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html#cfn-codepipeline-customactiontype-configurationproperties
	//
	ConfigurationProperties interface{} `field:"optional" json:"configurationProperties" yaml:"configurationProperties"`
	// URLs that provide users information about this custom action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html#cfn-codepipeline-customactiontype-settings
	//
	Settings interface{} `field:"optional" json:"settings" yaml:"settings"`
	// The tags for the custom action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html#cfn-codepipeline-customactiontype-tags
	//
	Tags *[]*awscdk.CfnTag `field:"optional" json:"tags" yaml:"tags"`
}

Properties for defining a `CfnCustomActionType`.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

cfnCustomActionTypeProps := &CfnCustomActionTypeProps{
	Category: jsii.String("category"),
	InputArtifactDetails: &ArtifactDetailsProperty{
		MaximumCount: jsii.Number(123),
		MinimumCount: jsii.Number(123),
	},
	OutputArtifactDetails: &ArtifactDetailsProperty{
		MaximumCount: jsii.Number(123),
		MinimumCount: jsii.Number(123),
	},
	Provider: jsii.String("provider"),
	Version: jsii.String("version"),

	// the properties below are optional
	ConfigurationProperties: []interface{}{
		&ConfigurationPropertiesProperty{
			Key: jsii.Boolean(false),
			Name: jsii.String("name"),
			Required: jsii.Boolean(false),
			Secret: jsii.Boolean(false),

			// the properties below are optional
			Description: jsii.String("description"),
			Queryable: jsii.Boolean(false),
			Type: jsii.String("type"),
		},
	},
	Settings: &SettingsProperty{
		EntityUrlTemplate: jsii.String("entityUrlTemplate"),
		ExecutionUrlTemplate: jsii.String("executionUrlTemplate"),
		RevisionUrlTemplate: jsii.String("revisionUrlTemplate"),
		ThirdPartyConfigurationUrl: jsii.String("thirdPartyConfigurationUrl"),
	},
	Tags: []cfnTag{
		&cfnTag{
			Key: jsii.String("key"),
			Value: jsii.String("value"),
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype.html

type CfnCustomActionType_ArtifactDetailsProperty

type CfnCustomActionType_ArtifactDetailsProperty struct {
	// The maximum number of artifacts allowed for the action type.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-artifactdetails.html#cfn-codepipeline-customactiontype-artifactdetails-maximumcount
	//
	MaximumCount *float64 `field:"required" json:"maximumCount" yaml:"maximumCount"`
	// The minimum number of artifacts allowed for the action type.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-artifactdetails.html#cfn-codepipeline-customactiontype-artifactdetails-minimumcount
	//
	MinimumCount *float64 `field:"required" json:"minimumCount" yaml:"minimumCount"`
}

Returns information about the details of an artifact.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

artifactDetailsProperty := &ArtifactDetailsProperty{
	MaximumCount: jsii.Number(123),
	MinimumCount: jsii.Number(123),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-artifactdetails.html

type CfnCustomActionType_ConfigurationPropertiesProperty

type CfnCustomActionType_ConfigurationPropertiesProperty struct {
	// Whether the configuration property is a key.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-key
	//
	Key interface{} `field:"required" json:"key" yaml:"key"`
	// The name of the action configuration property.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-name
	//
	Name *string `field:"required" json:"name" yaml:"name"`
	// Whether the configuration property is a required value.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-required
	//
	Required interface{} `field:"required" json:"required" yaml:"required"`
	// Whether the configuration property is secret.
	//
	// Secrets are hidden from all calls except for `GetJobDetails` , `GetThirdPartyJobDetails` , `PollForJobs` , and `PollForThirdPartyJobs` .
	//
	// When updating a pipeline, passing * * * * * without changing any other values of the action preserves the previous value of the secret.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-secret
	//
	Secret interface{} `field:"required" json:"secret" yaml:"secret"`
	// The description of the action configuration property that is displayed to users.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-description
	//
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Indicates that the property is used with `PollForJobs` .
	//
	// When creating a custom action, an action can have up to one queryable property. If it has one, that property must be both required and not secret.
	//
	// If you create a pipeline with a custom action type, and that custom action contains a queryable property, the value for that configuration property is subject to other restrictions. The value must be less than or equal to twenty (20) characters. The value can contain only alphanumeric characters, underscores, and hyphens.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-queryable
	//
	Queryable interface{} `field:"optional" json:"queryable" yaml:"queryable"`
	// The type of the configuration property.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-type
	//
	Type *string `field:"optional" json:"type" yaml:"type"`
}

The configuration properties for the custom action.

> You can refer to a name in the configuration properties of the custom action within the URL templates by following the format of {Config:name}, as long as the configuration property is both required and not secret. For more information, see [Create a Custom Action for a Pipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/how-to-create-custom-action.html) .

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

configurationPropertiesProperty := &ConfigurationPropertiesProperty{
	Key: jsii.Boolean(false),
	Name: jsii.String("name"),
	Required: jsii.Boolean(false),
	Secret: jsii.Boolean(false),

	// the properties below are optional
	Description: jsii.String("description"),
	Queryable: jsii.Boolean(false),
	Type: jsii.String("type"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-configurationproperties.html

type CfnCustomActionType_SettingsProperty

type CfnCustomActionType_SettingsProperty struct {
	// The URL returned to the CodePipeline console that provides a deep link to the resources of the external system, such as the configuration page for a CodeDeploy deployment group.
	//
	// This link is provided as part of the action display in the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-settings.html#cfn-codepipeline-customactiontype-settings-entityurltemplate
	//
	EntityUrlTemplate *string `field:"optional" json:"entityUrlTemplate" yaml:"entityUrlTemplate"`
	// The URL returned to the CodePipeline console that contains a link to the top-level landing page for the external system, such as the console page for CodeDeploy.
	//
	// This link is shown on the pipeline view page in the CodePipeline console and provides a link to the execution entity of the external action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-settings.html#cfn-codepipeline-customactiontype-settings-executionurltemplate
	//
	ExecutionUrlTemplate *string `field:"optional" json:"executionUrlTemplate" yaml:"executionUrlTemplate"`
	// The URL returned to the CodePipeline console that contains a link to the page where customers can update or change the configuration of the external action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-settings.html#cfn-codepipeline-customactiontype-settings-revisionurltemplate
	//
	RevisionUrlTemplate *string `field:"optional" json:"revisionUrlTemplate" yaml:"revisionUrlTemplate"`
	// The URL of a sign-up page where users can sign up for an external service and perform initial configuration of the action provided by that service.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-settings.html#cfn-codepipeline-customactiontype-settings-thirdpartyconfigurationurl
	//
	ThirdPartyConfigurationUrl *string `field:"optional" json:"thirdPartyConfigurationUrl" yaml:"thirdPartyConfigurationUrl"`
}

`Settings` is a property of the `AWS::CodePipeline::CustomActionType` resource that provides URLs that users can access to view information about the CodePipeline custom action.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

settingsProperty := &SettingsProperty{
	EntityUrlTemplate: jsii.String("entityUrlTemplate"),
	ExecutionUrlTemplate: jsii.String("executionUrlTemplate"),
	RevisionUrlTemplate: jsii.String("revisionUrlTemplate"),
	ThirdPartyConfigurationUrl: jsii.String("thirdPartyConfigurationUrl"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-customactiontype-settings.html

type CfnPipeline

type CfnPipeline interface {
	awscdk.CfnResource
	awscdk.IInspectable
	awscdk.ITaggable
	// The S3 bucket where artifacts for the pipeline are stored.
	ArtifactStore() interface{}
	SetArtifactStore(val interface{})
	// A mapping of `artifactStore` objects and their corresponding AWS Regions.
	ArtifactStores() interface{}
	SetArtifactStores(val interface{})
	// The version of the pipeline.
	//
	// > A new pipeline is always assigned a version number of 1. This number increments when a pipeline is updated.
	AttrVersion() *string
	// Options for this resource, such as condition, update policy etc.
	CfnOptions() awscdk.ICfnResourceOptions
	CfnProperties() *map[string]interface{}
	// AWS resource type.
	CfnResourceType() *string
	// Returns: the stack trace of the point where this Resource was created from, sourced
	// from the +metadata+ entry typed +aws:cdk:logicalId+, and with the bottom-most
	// node +internal+ entries filtered.
	CreationStack() *[]*string
	// Represents the input of a `DisableStageTransition` action.
	DisableInboundStageTransitions() interface{}
	SetDisableInboundStageTransitions(val interface{})
	// The method that the pipeline will use to handle multiple executions.
	ExecutionMode() *string
	SetExecutionMode(val *string)
	// The logical ID for this CloudFormation stack element.
	//
	// The logical ID of the element
	// is calculated from the path of the resource node in the construct tree.
	//
	// To override this value, use `overrideLogicalId(newLogicalId)`.
	//
	// Returns: the logical ID as a stringified token. This value will only get
	// resolved during synthesis.
	LogicalId() *string
	// The name of the pipeline.
	Name() *string
	SetName(val *string)
	// The tree node.
	Node() constructs.Node
	// CodePipeline provides the following pipeline types, which differ in characteristics and price, so that you can tailor your pipeline features and cost to the needs of your applications.
	PipelineType() *string
	SetPipelineType(val *string)
	// Return a string that will be resolved to a CloudFormation `{ Ref }` for this element.
	//
	// If, by any chance, the intrinsic reference of a resource is not a string, you could
	// coerce it to an IResolvable through `Lazy.any({ produce: resource.ref })`.
	Ref() *string
	// Indicates whether to rerun the CodePipeline pipeline after you update it.
	RestartExecutionOnUpdate() interface{}
	SetRestartExecutionOnUpdate(val interface{})
	// The Amazon Resource Name (ARN) for CodePipeline to use to either perform actions with no `actionRoleArn` , or to use to assume roles for actions with an `actionRoleArn` .
	RoleArn() *string
	SetRoleArn(val *string)
	// The stack in which this element is defined.
	//
	// CfnElements must be defined within a stack scope (directly or indirectly).
	Stack() awscdk.Stack
	// Represents information about a stage and its definition.
	Stages() interface{}
	SetStages(val interface{})
	// Tag Manager which manages the tags for this resource.
	Tags() awscdk.TagManager
	// Specifies the tags applied to the pipeline.
	TagsRaw() *[]*awscdk.CfnTag
	SetTagsRaw(val *[]*awscdk.CfnTag)
	// The trigger configuration specifying a type of event, such as Git tags, that starts the pipeline.
	Triggers() interface{}
	SetTriggers(val interface{})
	// Deprecated.
	// Deprecated: use `updatedProperties`
	//
	// Return properties modified after initiation
	//
	// Resources that expose mutable properties should override this function to
	// collect and return the properties object for this resource.
	UpdatedProperites() *map[string]interface{}
	// Return properties modified after initiation.
	//
	// Resources that expose mutable properties should override this function to
	// collect and return the properties object for this resource.
	UpdatedProperties() *map[string]interface{}
	// A list that defines the pipeline variables for a pipeline resource.
	Variables() interface{}
	SetVariables(val interface{})
	// Syntactic sugar for `addOverride(path, undefined)`.
	AddDeletionOverride(path *string)
	// Indicates that this resource depends on another resource and cannot be provisioned unless the other resource has been successfully provisioned.
	//
	// This can be used for resources across stacks (or nested stack) boundaries
	// and the dependency will automatically be transferred to the relevant scope.
	AddDependency(target awscdk.CfnResource)
	// Indicates that this resource depends on another resource and cannot be provisioned unless the other resource has been successfully provisioned.
	// Deprecated: use addDependency.
	AddDependsOn(target awscdk.CfnResource)
	// Add a value to the CloudFormation Resource Metadata.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html
	//
	// Note that this is a different set of metadata from CDK node metadata; this
	// metadata ends up in the stack template under the resource, whereas CDK
	// node metadata ends up in the Cloud Assembly.
	//
	AddMetadata(key *string, value interface{})
	// Adds an override to the synthesized CloudFormation resource.
	//
	// To add a
	// property override, either use `addPropertyOverride` or prefix `path` with
	// "Properties." (i.e. `Properties.TopicName`).
	//
	// If the override is nested, separate each nested level using a dot (.) in the path parameter.
	// If there is an array as part of the nesting, specify the index in the path.
	//
	// To include a literal `.` in the property name, prefix with a `\`. In most
	// programming languages you will need to write this as `"\\."` because the
	// `\` itself will need to be escaped.
	//
	// For example,
	// “`typescript
	// cfnResource.addOverride('Properties.GlobalSecondaryIndexes.0.Projection.NonKeyAttributes', ['myattribute']);
	// cfnResource.addOverride('Properties.GlobalSecondaryIndexes.1.ProjectionType', 'INCLUDE');
	// “`
	// would add the overrides
	// “`json
	// "Properties": {
	//   "GlobalSecondaryIndexes": [
	//     {
	//       "Projection": {
	//         "NonKeyAttributes": [ "myattribute" ]
	//         ...
	//       }
	//       ...
	//     },
	//     {
	//       "ProjectionType": "INCLUDE"
	//       ...
	//     },
	//   ]
	//   ...
	// }
	// “`
	//
	// The `value` argument to `addOverride` will not be processed or translated
	// in any way. Pass raw JSON values in here with the correct capitalization
	// for CloudFormation. If you pass CDK classes or structs, they will be
	// rendered with lowercased key names, and CloudFormation will reject the
	// template.
	AddOverride(path *string, value interface{})
	// Adds an override that deletes the value of a property from the resource definition.
	AddPropertyDeletionOverride(propertyPath *string)
	// Adds an override to a resource property.
	//
	// Syntactic sugar for `addOverride("Properties.<...>", value)`.
	AddPropertyOverride(propertyPath *string, value interface{})
	// Sets the deletion policy of the resource based on the removal policy specified.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`). In some
	// cases, a snapshot can be taken of the resource prior to deletion
	// (`RemovalPolicy.SNAPSHOT`). A list of resources that support this policy
	// can be found in the following link:.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html#aws-attribute-deletionpolicy-options
	//
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy, options *awscdk.RemovalPolicyOptions)
	// Returns a token for an runtime attribute of this resource.
	//
	// Ideally, use generated attribute accessors (e.g. `resource.arn`), but this can be used for future compatibility
	// in case there is no generated attribute.
	GetAtt(attributeName *string, typeHint awscdk.ResolutionTypeHint) awscdk.Reference
	// Retrieve a value value from the CloudFormation Resource Metadata.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html
	//
	// Note that this is a different set of metadata from CDK node metadata; this
	// metadata ends up in the stack template under the resource, whereas CDK
	// node metadata ends up in the Cloud Assembly.
	//
	GetMetadata(key *string) interface{}
	// Examines the CloudFormation resource and discloses attributes.
	Inspect(inspector awscdk.TreeInspector)
	// Retrieves an array of resources this resource depends on.
	//
	// This assembles dependencies on resources across stacks (including nested stacks)
	// automatically.
	ObtainDependencies() *[]interface{}
	// Get a shallow copy of dependencies between this resource and other resources in the same stack.
	ObtainResourceDependencies() *[]awscdk.CfnResource
	// Overrides the auto-generated logical ID with a specific ID.
	OverrideLogicalId(newLogicalId *string)
	// Indicates that this resource no longer depends on another resource.
	//
	// This can be used for resources across stacks (including nested stacks)
	// and the dependency will automatically be removed from the relevant scope.
	RemoveDependency(target awscdk.CfnResource)
	RenderProperties(props *map[string]interface{}) *map[string]interface{}
	// Replaces one dependency with another.
	ReplaceDependency(target awscdk.CfnResource, newTarget awscdk.CfnResource)
	// Can be overridden by subclasses to determine if this resource will be rendered into the cloudformation template.
	//
	// Returns: `true` if the resource should be included or `false` is the resource
	// should be omitted.
	ShouldSynthesize() *bool
	// Returns a string representation of this construct.
	//
	// Returns: a string representation of this resource.
	ToString() *string
	ValidateProperties(_properties interface{})
}

The `AWS::CodePipeline::Pipeline` resource creates a CodePipeline pipeline that describes how software changes go through a release process.

For more information, see [What Is CodePipeline?](https://docs.aws.amazon.com/codepipeline/latest/userguide/welcome.html) in the *CodePipeline User Guide* .

For an example in YAML and JSON that contains the parameters in this reference, see [Examples](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#aws-resource-codepipeline-pipeline--examples) .

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

cfnPipeline := awscdk.Aws_codepipeline.NewCfnPipeline(this, jsii.String("MyCfnPipeline"), &CfnPipelineProps{
	RoleArn: jsii.String("roleArn"),
	Stages: []interface{}{
		&StageDeclarationProperty{
			Actions: []interface{}{
				&ActionDeclarationProperty{
					ActionTypeId: &ActionTypeIdProperty{
						Category: jsii.String("category"),
						Owner: jsii.String("owner"),
						Provider: jsii.String("provider"),
						Version: jsii.String("version"),
					},
					Name: jsii.String("name"),

					// the properties below are optional
					Configuration: configuration,
					InputArtifacts: []interface{}{
						&InputArtifactProperty{
							Name: jsii.String("name"),
						},
					},
					Namespace: jsii.String("namespace"),
					OutputArtifacts: []interface{}{
						&OutputArtifactProperty{
							Name: jsii.String("name"),
						},
					},
					Region: jsii.String("region"),
					RoleArn: jsii.String("roleArn"),
					RunOrder: jsii.Number(123),
					TimeoutInMinutes: jsii.Number(123),
				},
			},
			Name: jsii.String("name"),

			// the properties below are optional
			BeforeEntry: &BeforeEntryConditionsProperty{
				Conditions: []interface{}{
					&ConditionProperty{
						Result: jsii.String("result"),
						Rules: []interface{}{
							&RuleDeclarationProperty{
								Configuration: configuration,
								InputArtifacts: []interface{}{
									&InputArtifactProperty{
										Name: jsii.String("name"),
									},
								},
								Name: jsii.String("name"),
								Region: jsii.String("region"),
								RoleArn: jsii.String("roleArn"),
								RuleTypeId: &RuleTypeIdProperty{
									Category: jsii.String("category"),
									Owner: jsii.String("owner"),
									Provider: jsii.String("provider"),
									Version: jsii.String("version"),
								},
							},
						},
					},
				},
			},
			Blockers: []interface{}{
				&BlockerDeclarationProperty{
					Name: jsii.String("name"),
					Type: jsii.String("type"),
				},
			},
			OnFailure: &FailureConditionsProperty{
				Conditions: []interface{}{
					&ConditionProperty{
						Result: jsii.String("result"),
						Rules: []interface{}{
							&RuleDeclarationProperty{
								Configuration: configuration,
								InputArtifacts: []interface{}{
									&InputArtifactProperty{
										Name: jsii.String("name"),
									},
								},
								Name: jsii.String("name"),
								Region: jsii.String("region"),
								RoleArn: jsii.String("roleArn"),
								RuleTypeId: &RuleTypeIdProperty{
									Category: jsii.String("category"),
									Owner: jsii.String("owner"),
									Provider: jsii.String("provider"),
									Version: jsii.String("version"),
								},
							},
						},
					},
				},
				Result: jsii.String("result"),
			},
			OnSuccess: &SuccessConditionsProperty{
				Conditions: []interface{}{
					&ConditionProperty{
						Result: jsii.String("result"),
						Rules: []interface{}{
							&RuleDeclarationProperty{
								Configuration: configuration,
								InputArtifacts: []interface{}{
									&InputArtifactProperty{
										Name: jsii.String("name"),
									},
								},
								Name: jsii.String("name"),
								Region: jsii.String("region"),
								RoleArn: jsii.String("roleArn"),
								RuleTypeId: &RuleTypeIdProperty{
									Category: jsii.String("category"),
									Owner: jsii.String("owner"),
									Provider: jsii.String("provider"),
									Version: jsii.String("version"),
								},
							},
						},
					},
				},
			},
		},
	},

	// the properties below are optional
	ArtifactStore: &ArtifactStoreProperty{
		Location: jsii.String("location"),
		Type: jsii.String("type"),

		// the properties below are optional
		EncryptionKey: &EncryptionKeyProperty{
			Id: jsii.String("id"),
			Type: jsii.String("type"),
		},
	},
	ArtifactStores: []interface{}{
		&ArtifactStoreMapProperty{
			ArtifactStore: &ArtifactStoreProperty{
				Location: jsii.String("location"),
				Type: jsii.String("type"),

				// the properties below are optional
				EncryptionKey: &EncryptionKeyProperty{
					Id: jsii.String("id"),
					Type: jsii.String("type"),
				},
			},
			Region: jsii.String("region"),
		},
	},
	DisableInboundStageTransitions: []interface{}{
		&StageTransitionProperty{
			Reason: jsii.String("reason"),
			StageName: jsii.String("stageName"),
		},
	},
	ExecutionMode: jsii.String("executionMode"),
	Name: jsii.String("name"),
	PipelineType: jsii.String("pipelineType"),
	RestartExecutionOnUpdate: jsii.Boolean(false),
	Tags: []cfnTag{
		&cfnTag{
			Key: jsii.String("key"),
			Value: jsii.String("value"),
		},
	},
	Triggers: []interface{}{
		&PipelineTriggerDeclarationProperty{
			ProviderType: jsii.String("providerType"),

			// the properties below are optional
			GitConfiguration: &GitConfigurationProperty{
				SourceActionName: jsii.String("sourceActionName"),

				// the properties below are optional
				PullRequest: []interface{}{
					&GitPullRequestFilterProperty{
						Branches: &GitBranchFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
						Events: []*string{
							jsii.String("events"),
						},
						FilePaths: &GitFilePathFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
					},
				},
				Push: []interface{}{
					&GitPushFilterProperty{
						Branches: &GitBranchFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
						FilePaths: &GitFilePathFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
						Tags: &GitTagFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
					},
				},
			},
		},
	},
	Variables: []interface{}{
		&VariableDeclarationProperty{
			Name: jsii.String("name"),

			// the properties below are optional
			DefaultValue: jsii.String("defaultValue"),
			Description: jsii.String("description"),
		},
	},
})

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html

func NewCfnPipeline

func NewCfnPipeline(scope constructs.Construct, id *string, props *CfnPipelineProps) CfnPipeline

type CfnPipelineProps

type CfnPipelineProps struct {
	// The Amazon Resource Name (ARN) for CodePipeline to use to either perform actions with no `actionRoleArn` , or to use to assume roles for actions with an `actionRoleArn` .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-rolearn
	//
	RoleArn *string `field:"required" json:"roleArn" yaml:"roleArn"`
	// Represents information about a stage and its definition.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-stages
	//
	Stages interface{} `field:"required" json:"stages" yaml:"stages"`
	// The S3 bucket where artifacts for the pipeline are stored.
	//
	// > You must include either `artifactStore` or `artifactStores` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use `artifactStores` .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-artifactstore
	//
	ArtifactStore interface{} `field:"optional" json:"artifactStore" yaml:"artifactStore"`
	// A mapping of `artifactStore` objects and their corresponding AWS Regions.
	//
	// There must be an artifact store for the pipeline Region and for each cross-region action in the pipeline.
	//
	// > You must include either `artifactStore` or `artifactStores` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use `artifactStores` .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-artifactstores
	//
	ArtifactStores interface{} `field:"optional" json:"artifactStores" yaml:"artifactStores"`
	// Represents the input of a `DisableStageTransition` action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-disableinboundstagetransitions
	//
	DisableInboundStageTransitions interface{} `field:"optional" json:"disableInboundStageTransitions" yaml:"disableInboundStageTransitions"`
	// The method that the pipeline will use to handle multiple executions.
	//
	// The default mode is SUPERSEDED.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-executionmode
	//
	// Default: - "SUPERSEDED".
	//
	ExecutionMode *string `field:"optional" json:"executionMode" yaml:"executionMode"`
	// The name of the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-name
	//
	Name *string `field:"optional" json:"name" yaml:"name"`
	// CodePipeline provides the following pipeline types, which differ in characteristics and price, so that you can tailor your pipeline features and cost to the needs of your applications.
	//
	// - V1 type pipelines have a JSON structure that contains standard pipeline, stage, and action-level parameters.
	// - V2 type pipelines have the same structure as a V1 type, along with additional parameters for release safety and trigger configuration.
	//
	// > Including V2 parameters, such as triggers on Git tags, in the pipeline JSON when creating or updating a pipeline will result in the pipeline having the V2 type of pipeline and the associated costs.
	//
	// For information about pricing for CodePipeline, see [Pricing](https://docs.aws.amazon.com/codepipeline/pricing/) .
	//
	// For information about which type of pipeline to choose, see [What type of pipeline is right for me?](https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html) .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-pipelinetype
	//
	PipelineType *string `field:"optional" json:"pipelineType" yaml:"pipelineType"`
	// Indicates whether to rerun the CodePipeline pipeline after you update it.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-restartexecutiononupdate
	//
	RestartExecutionOnUpdate interface{} `field:"optional" json:"restartExecutionOnUpdate" yaml:"restartExecutionOnUpdate"`
	// Specifies the tags applied to the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-tags
	//
	Tags *[]*awscdk.CfnTag `field:"optional" json:"tags" yaml:"tags"`
	// The trigger configuration specifying a type of event, such as Git tags, that starts the pipeline.
	//
	// > When a trigger configuration is specified, default change detection for repository and branch commits is disabled.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-triggers
	//
	Triggers interface{} `field:"optional" json:"triggers" yaml:"triggers"`
	// A list that defines the pipeline variables for a pipeline resource.
	//
	// Variable names can have alphanumeric and underscore characters, and the values must match `[A-Za-z0-9@\-_]+` .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html#cfn-codepipeline-pipeline-variables
	//
	Variables interface{} `field:"optional" json:"variables" yaml:"variables"`
}

Properties for defining a `CfnPipeline`.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

cfnPipelineProps := &CfnPipelineProps{
	RoleArn: jsii.String("roleArn"),
	Stages: []interface{}{
		&StageDeclarationProperty{
			Actions: []interface{}{
				&ActionDeclarationProperty{
					ActionTypeId: &ActionTypeIdProperty{
						Category: jsii.String("category"),
						Owner: jsii.String("owner"),
						Provider: jsii.String("provider"),
						Version: jsii.String("version"),
					},
					Name: jsii.String("name"),

					// the properties below are optional
					Configuration: configuration,
					InputArtifacts: []interface{}{
						&InputArtifactProperty{
							Name: jsii.String("name"),
						},
					},
					Namespace: jsii.String("namespace"),
					OutputArtifacts: []interface{}{
						&OutputArtifactProperty{
							Name: jsii.String("name"),
						},
					},
					Region: jsii.String("region"),
					RoleArn: jsii.String("roleArn"),
					RunOrder: jsii.Number(123),
					TimeoutInMinutes: jsii.Number(123),
				},
			},
			Name: jsii.String("name"),

			// the properties below are optional
			BeforeEntry: &BeforeEntryConditionsProperty{
				Conditions: []interface{}{
					&ConditionProperty{
						Result: jsii.String("result"),
						Rules: []interface{}{
							&RuleDeclarationProperty{
								Configuration: configuration,
								InputArtifacts: []interface{}{
									&InputArtifactProperty{
										Name: jsii.String("name"),
									},
								},
								Name: jsii.String("name"),
								Region: jsii.String("region"),
								RoleArn: jsii.String("roleArn"),
								RuleTypeId: &RuleTypeIdProperty{
									Category: jsii.String("category"),
									Owner: jsii.String("owner"),
									Provider: jsii.String("provider"),
									Version: jsii.String("version"),
								},
							},
						},
					},
				},
			},
			Blockers: []interface{}{
				&BlockerDeclarationProperty{
					Name: jsii.String("name"),
					Type: jsii.String("type"),
				},
			},
			OnFailure: &FailureConditionsProperty{
				Conditions: []interface{}{
					&ConditionProperty{
						Result: jsii.String("result"),
						Rules: []interface{}{
							&RuleDeclarationProperty{
								Configuration: configuration,
								InputArtifacts: []interface{}{
									&InputArtifactProperty{
										Name: jsii.String("name"),
									},
								},
								Name: jsii.String("name"),
								Region: jsii.String("region"),
								RoleArn: jsii.String("roleArn"),
								RuleTypeId: &RuleTypeIdProperty{
									Category: jsii.String("category"),
									Owner: jsii.String("owner"),
									Provider: jsii.String("provider"),
									Version: jsii.String("version"),
								},
							},
						},
					},
				},
				Result: jsii.String("result"),
			},
			OnSuccess: &SuccessConditionsProperty{
				Conditions: []interface{}{
					&ConditionProperty{
						Result: jsii.String("result"),
						Rules: []interface{}{
							&RuleDeclarationProperty{
								Configuration: configuration,
								InputArtifacts: []interface{}{
									&InputArtifactProperty{
										Name: jsii.String("name"),
									},
								},
								Name: jsii.String("name"),
								Region: jsii.String("region"),
								RoleArn: jsii.String("roleArn"),
								RuleTypeId: &RuleTypeIdProperty{
									Category: jsii.String("category"),
									Owner: jsii.String("owner"),
									Provider: jsii.String("provider"),
									Version: jsii.String("version"),
								},
							},
						},
					},
				},
			},
		},
	},

	// the properties below are optional
	ArtifactStore: &ArtifactStoreProperty{
		Location: jsii.String("location"),
		Type: jsii.String("type"),

		// the properties below are optional
		EncryptionKey: &EncryptionKeyProperty{
			Id: jsii.String("id"),
			Type: jsii.String("type"),
		},
	},
	ArtifactStores: []interface{}{
		&ArtifactStoreMapProperty{
			ArtifactStore: &ArtifactStoreProperty{
				Location: jsii.String("location"),
				Type: jsii.String("type"),

				// the properties below are optional
				EncryptionKey: &EncryptionKeyProperty{
					Id: jsii.String("id"),
					Type: jsii.String("type"),
				},
			},
			Region: jsii.String("region"),
		},
	},
	DisableInboundStageTransitions: []interface{}{
		&StageTransitionProperty{
			Reason: jsii.String("reason"),
			StageName: jsii.String("stageName"),
		},
	},
	ExecutionMode: jsii.String("executionMode"),
	Name: jsii.String("name"),
	PipelineType: jsii.String("pipelineType"),
	RestartExecutionOnUpdate: jsii.Boolean(false),
	Tags: []cfnTag{
		&cfnTag{
			Key: jsii.String("key"),
			Value: jsii.String("value"),
		},
	},
	Triggers: []interface{}{
		&PipelineTriggerDeclarationProperty{
			ProviderType: jsii.String("providerType"),

			// the properties below are optional
			GitConfiguration: &GitConfigurationProperty{
				SourceActionName: jsii.String("sourceActionName"),

				// the properties below are optional
				PullRequest: []interface{}{
					&GitPullRequestFilterProperty{
						Branches: &GitBranchFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
						Events: []*string{
							jsii.String("events"),
						},
						FilePaths: &GitFilePathFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
					},
				},
				Push: []interface{}{
					&GitPushFilterProperty{
						Branches: &GitBranchFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
						FilePaths: &GitFilePathFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
						Tags: &GitTagFilterCriteriaProperty{
							Excludes: []*string{
								jsii.String("excludes"),
							},
							Includes: []*string{
								jsii.String("includes"),
							},
						},
					},
				},
			},
		},
	},
	Variables: []interface{}{
		&VariableDeclarationProperty{
			Name: jsii.String("name"),

			// the properties below are optional
			DefaultValue: jsii.String("defaultValue"),
			Description: jsii.String("description"),
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html

type CfnPipeline_ActionDeclarationProperty

type CfnPipeline_ActionDeclarationProperty struct {
	// Specifies the action type and the provider of the action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-actiontypeid
	//
	ActionTypeId interface{} `field:"required" json:"actionTypeId" yaml:"actionTypeId"`
	// The action declaration's name.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-name
	//
	Name *string `field:"required" json:"name" yaml:"name"`
	// The action's configuration.
	//
	// These are key-value pairs that specify input values for an action. For more information, see [Action Structure Requirements in CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements) . For the list of configuration properties for the AWS CloudFormation action type in CodePipeline, see [Configuration Properties Reference](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-action-reference.html) in the *AWS CloudFormation User Guide* . For template snippets with examples, see [Using Parameter Override Functions with CodePipeline Pipelines](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/continuous-delivery-codepipeline-parameter-override-functions.html) in the *AWS CloudFormation User Guide* .
	//
	// The values can be represented in either JSON or YAML format. For example, the JSON configuration item format is as follows:
	//
	// *JSON:*
	//
	// `"Configuration" : { Key : Value },`.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-configuration
	//
	Configuration interface{} `field:"optional" json:"configuration" yaml:"configuration"`
	// The name or ID of the artifact consumed by the action, such as a test or build artifact.
	//
	// While the field is not a required parameter, most actions have an action configuration that requires a specified quantity of input artifacts. To refer to the action configuration specification by action provider, see the [Action structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference.html) in the *AWS CodePipeline User Guide* .
	//
	// > For a CodeBuild action with multiple input artifacts, one of your input sources must be designated the PrimarySource. For more information, see the [CodeBuild action reference page](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference-CodeBuild.html) in the *AWS CodePipeline User Guide* .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-inputartifacts
	//
	InputArtifacts interface{} `field:"optional" json:"inputArtifacts" yaml:"inputArtifacts"`
	// The variable namespace associated with the action.
	//
	// All variables produced as output by this action fall under this namespace.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-namespace
	//
	Namespace *string `field:"optional" json:"namespace" yaml:"namespace"`
	// The name or ID of the result of the action declaration, such as a test or build artifact.
	//
	// While the field is not a required parameter, most actions have an action configuration that requires a specified quantity of output artifacts. To refer to the action configuration specification by action provider, see the [Action structure reference](https://docs.aws.amazon.com/codepipeline/latest/userguide/action-reference.html) in the *AWS CodePipeline User Guide* .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-outputartifacts
	//
	OutputArtifacts interface{} `field:"optional" json:"outputArtifacts" yaml:"outputArtifacts"`
	// The action declaration's AWS Region, such as us-east-1.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-region
	//
	Region *string `field:"optional" json:"region" yaml:"region"`
	// The ARN of the IAM service role that performs the declared action.
	//
	// This is assumed through the roleArn for the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-rolearn
	//
	RoleArn *string `field:"optional" json:"roleArn" yaml:"roleArn"`
	// The order in which actions are run.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-runorder
	//
	RunOrder *float64 `field:"optional" json:"runOrder" yaml:"runOrder"`
	// A timeout duration in minutes that can be applied against the ActionType’s default timeout value specified in [Quotas for AWS CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/limits.html) . This attribute is available only to the manual approval ActionType.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html#cfn-codepipeline-pipeline-actiondeclaration-timeoutinminutes
	//
	TimeoutInMinutes *float64 `field:"optional" json:"timeoutInMinutes" yaml:"timeoutInMinutes"`
}

Represents information about an action declaration.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

actionDeclarationProperty := &ActionDeclarationProperty{
	ActionTypeId: &ActionTypeIdProperty{
		Category: jsii.String("category"),
		Owner: jsii.String("owner"),
		Provider: jsii.String("provider"),
		Version: jsii.String("version"),
	},
	Name: jsii.String("name"),

	// the properties below are optional
	Configuration: configuration,
	InputArtifacts: []interface{}{
		&InputArtifactProperty{
			Name: jsii.String("name"),
		},
	},
	Namespace: jsii.String("namespace"),
	OutputArtifacts: []interface{}{
		&OutputArtifactProperty{
			Name: jsii.String("name"),
		},
	},
	Region: jsii.String("region"),
	RoleArn: jsii.String("roleArn"),
	RunOrder: jsii.Number(123),
	TimeoutInMinutes: jsii.Number(123),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiondeclaration.html

type CfnPipeline_ActionTypeIdProperty

type CfnPipeline_ActionTypeIdProperty struct {
	// A category defines what kind of action can be taken in the stage, and constrains the provider type for the action.
	//
	// Valid categories are limited to one of the values below.
	//
	// - `Source`
	// - `Build`
	// - `Test`
	// - `Deploy`
	// - `Invoke`
	// - `Approval`.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiontypeid.html#cfn-codepipeline-pipeline-actiontypeid-category
	//
	Category *string `field:"required" json:"category" yaml:"category"`
	// The creator of the action being called.
	//
	// There are three valid values for the `Owner` field in the action category section within your pipeline structure: `AWS` , `ThirdParty` , and `Custom` . For more information, see [Valid Action Types and Providers in CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#actions-valid-providers) .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiontypeid.html#cfn-codepipeline-pipeline-actiontypeid-owner
	//
	Owner *string `field:"required" json:"owner" yaml:"owner"`
	// The provider of the service being called by the action.
	//
	// Valid providers are determined by the action category. For example, an action in the Deploy category type might have a provider of CodeDeploy, which would be specified as `CodeDeploy` . For more information, see [Valid Action Types and Providers in CodePipeline](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#actions-valid-providers) .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiontypeid.html#cfn-codepipeline-pipeline-actiontypeid-provider
	//
	Provider *string `field:"required" json:"provider" yaml:"provider"`
	// A string that describes the action version.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiontypeid.html#cfn-codepipeline-pipeline-actiontypeid-version
	//
	Version *string `field:"required" json:"version" yaml:"version"`
}

Represents information about an action type.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

actionTypeIdProperty := &ActionTypeIdProperty{
	Category: jsii.String("category"),
	Owner: jsii.String("owner"),
	Provider: jsii.String("provider"),
	Version: jsii.String("version"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-actiontypeid.html

type CfnPipeline_ArtifactStoreMapProperty

type CfnPipeline_ArtifactStoreMapProperty struct {
	// Represents information about the S3 bucket where artifacts are stored for the pipeline.
	//
	// > You must include either `artifactStore` or `artifactStores` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use `artifactStores` .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-artifactstoremap.html#cfn-codepipeline-pipeline-artifactstoremap-artifactstore
	//
	ArtifactStore interface{} `field:"required" json:"artifactStore" yaml:"artifactStore"`
	// The action declaration's AWS Region, such as us-east-1.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-artifactstoremap.html#cfn-codepipeline-pipeline-artifactstoremap-region
	//
	Region *string `field:"required" json:"region" yaml:"region"`
}

A mapping of `artifactStore` objects and their corresponding AWS Regions.

There must be an artifact store for the pipeline Region and for each cross-region action in the pipeline.

> You must include either `artifactStore` or `artifactStores` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use `artifactStores` .

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

artifactStoreMapProperty := &ArtifactStoreMapProperty{
	ArtifactStore: &ArtifactStoreProperty{
		Location: jsii.String("location"),
		Type: jsii.String("type"),

		// the properties below are optional
		EncryptionKey: &EncryptionKeyProperty{
			Id: jsii.String("id"),
			Type: jsii.String("type"),
		},
	},
	Region: jsii.String("region"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-artifactstoremap.html

type CfnPipeline_ArtifactStoreProperty

type CfnPipeline_ArtifactStoreProperty struct {
	// The S3 bucket used for storing the artifacts for a pipeline.
	//
	// You can specify the name of an S3 bucket but not a folder in the bucket. A folder to contain the pipeline artifacts is created for you based on the name of the pipeline. You can use any S3 bucket in the same AWS Region as the pipeline to store your pipeline artifacts.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-artifactstore.html#cfn-codepipeline-pipeline-artifactstore-location
	//
	Location *string `field:"required" json:"location" yaml:"location"`
	// The type of the artifact store, such as S3.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-artifactstore.html#cfn-codepipeline-pipeline-artifactstore-type
	//
	Type *string `field:"required" json:"type" yaml:"type"`
	// The encryption key used to encrypt the data in the artifact store, such as an AWS Key Management Service ( AWS KMS) key.
	//
	// If this is undefined, the default key for Amazon S3 is used. To see an example artifact store encryption key field, see the example structure here: [AWS::CodePipeline::Pipeline](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-pipeline.html) .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-artifactstore.html#cfn-codepipeline-pipeline-artifactstore-encryptionkey
	//
	EncryptionKey interface{} `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
}

The S3 bucket where artifacts for the pipeline are stored.

> You must include either `artifactStore` or `artifactStores` in your pipeline, but you cannot use both. If you create a cross-region action in your pipeline, you must use `artifactStores` .

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

artifactStoreProperty := &ArtifactStoreProperty{
	Location: jsii.String("location"),
	Type: jsii.String("type"),

	// the properties below are optional
	EncryptionKey: &EncryptionKeyProperty{
		Id: jsii.String("id"),
		Type: jsii.String("type"),
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-artifactstore.html

type CfnPipeline_BeforeEntryConditionsProperty

type CfnPipeline_BeforeEntryConditionsProperty struct {
	// The conditions that are configured as entry conditions.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-beforeentryconditions.html#cfn-codepipeline-pipeline-beforeentryconditions-conditions
	//
	Conditions interface{} `field:"optional" json:"conditions" yaml:"conditions"`
}

The conditions for making checks for entry to a stage.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

beforeEntryConditionsProperty := &BeforeEntryConditionsProperty{
	Conditions: []interface{}{
		&ConditionProperty{
			Result: jsii.String("result"),
			Rules: []interface{}{
				&RuleDeclarationProperty{
					Configuration: configuration,
					InputArtifacts: []interface{}{
						&InputArtifactProperty{
							Name: jsii.String("name"),
						},
					},
					Name: jsii.String("name"),
					Region: jsii.String("region"),
					RoleArn: jsii.String("roleArn"),
					RuleTypeId: &RuleTypeIdProperty{
						Category: jsii.String("category"),
						Owner: jsii.String("owner"),
						Provider: jsii.String("provider"),
						Version: jsii.String("version"),
					},
				},
			},
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-beforeentryconditions.html

type CfnPipeline_BlockerDeclarationProperty

type CfnPipeline_BlockerDeclarationProperty struct {
	// Reserved for future use.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-blockerdeclaration.html#cfn-codepipeline-pipeline-blockerdeclaration-name
	//
	Name *string `field:"required" json:"name" yaml:"name"`
	// Reserved for future use.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-blockerdeclaration.html#cfn-codepipeline-pipeline-blockerdeclaration-type
	//
	Type *string `field:"required" json:"type" yaml:"type"`
}

Reserved for future use.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

blockerDeclarationProperty := &BlockerDeclarationProperty{
	Name: jsii.String("name"),
	Type: jsii.String("type"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-blockerdeclaration.html

type CfnPipeline_ConditionProperty

type CfnPipeline_ConditionProperty struct {
	// The action to be done when the condition is met.
	//
	// For example, rolling back an execution for a failure condition.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-condition.html#cfn-codepipeline-pipeline-condition-result
	//
	Result *string `field:"optional" json:"result" yaml:"result"`
	// The rules that make up the condition.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-condition.html#cfn-codepipeline-pipeline-condition-rules
	//
	Rules interface{} `field:"optional" json:"rules" yaml:"rules"`
}

The condition for the stage.

A condition is made up of the rules and the result for the condition.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

conditionProperty := &ConditionProperty{
	Result: jsii.String("result"),
	Rules: []interface{}{
		&RuleDeclarationProperty{
			Configuration: configuration,
			InputArtifacts: []interface{}{
				&InputArtifactProperty{
					Name: jsii.String("name"),
				},
			},
			Name: jsii.String("name"),
			Region: jsii.String("region"),
			RoleArn: jsii.String("roleArn"),
			RuleTypeId: &RuleTypeIdProperty{
				Category: jsii.String("category"),
				Owner: jsii.String("owner"),
				Provider: jsii.String("provider"),
				Version: jsii.String("version"),
			},
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-condition.html

type CfnPipeline_EncryptionKeyProperty

type CfnPipeline_EncryptionKeyProperty struct {
	// The ID used to identify the key.
	//
	// For an AWS KMS key, you can use the key ID, the key ARN, or the alias ARN.
	//
	// > Aliases are recognized only in the account that created the AWS KMS key. For cross-account actions, you can only use the key ID or key ARN to identify the key. Cross-account actions involve using the role from the other account (AccountB), so specifying the key ID will use the key from the other account (AccountB).
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-encryptionkey.html#cfn-codepipeline-pipeline-encryptionkey-id
	//
	Id *string `field:"required" json:"id" yaml:"id"`
	// The type of encryption key, such as an AWS KMS key.
	//
	// When creating or updating a pipeline, the value must be set to 'KMS'.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-encryptionkey.html#cfn-codepipeline-pipeline-encryptionkey-type
	//
	Type *string `field:"required" json:"type" yaml:"type"`
}

Represents information about the key used to encrypt data in the artifact store, such as an AWS Key Management Service ( AWS KMS) key.

`EncryptionKey` is a property of the [ArtifactStore](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-artifactstore.html) property type.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

encryptionKeyProperty := &EncryptionKeyProperty{
	Id: jsii.String("id"),
	Type: jsii.String("type"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-encryptionkey.html

type CfnPipeline_FailureConditionsProperty

type CfnPipeline_FailureConditionsProperty struct {
	// The conditions that are configured as failure conditions.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-failureconditions.html#cfn-codepipeline-pipeline-failureconditions-conditions
	//
	Conditions interface{} `field:"optional" json:"conditions" yaml:"conditions"`
	// The specified result for when the failure conditions are met, such as rolling back the stage.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-failureconditions.html#cfn-codepipeline-pipeline-failureconditions-result
	//
	Result *string `field:"optional" json:"result" yaml:"result"`
}

The configuration that specifies the result, such as rollback, to occur upon stage failure.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

failureConditionsProperty := &FailureConditionsProperty{
	Conditions: []interface{}{
		&ConditionProperty{
			Result: jsii.String("result"),
			Rules: []interface{}{
				&RuleDeclarationProperty{
					Configuration: configuration,
					InputArtifacts: []interface{}{
						&InputArtifactProperty{
							Name: jsii.String("name"),
						},
					},
					Name: jsii.String("name"),
					Region: jsii.String("region"),
					RoleArn: jsii.String("roleArn"),
					RuleTypeId: &RuleTypeIdProperty{
						Category: jsii.String("category"),
						Owner: jsii.String("owner"),
						Provider: jsii.String("provider"),
						Version: jsii.String("version"),
					},
				},
			},
		},
	},
	Result: jsii.String("result"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-failureconditions.html

type CfnPipeline_GitBranchFilterCriteriaProperty

type CfnPipeline_GitBranchFilterCriteriaProperty struct {
	// The list of patterns of Git branches that, when a commit is pushed, are to be excluded from starting the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitbranchfiltercriteria.html#cfn-codepipeline-pipeline-gitbranchfiltercriteria-excludes
	//
	Excludes *[]*string `field:"optional" json:"excludes" yaml:"excludes"`
	// The list of patterns of Git branches that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitbranchfiltercriteria.html#cfn-codepipeline-pipeline-gitbranchfiltercriteria-includes
	//
	Includes *[]*string `field:"optional" json:"includes" yaml:"includes"`
}

The Git repository branches specified as filter criteria to start the pipeline.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

gitBranchFilterCriteriaProperty := &GitBranchFilterCriteriaProperty{
	Excludes: []*string{
		jsii.String("excludes"),
	},
	Includes: []*string{
		jsii.String("includes"),
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitbranchfiltercriteria.html

type CfnPipeline_GitConfigurationProperty

type CfnPipeline_GitConfigurationProperty struct {
	// The name of the pipeline source action where the trigger configuration, such as Git tags, is specified.
	//
	// The trigger configuration will start the pipeline upon the specified change only.
	//
	// > You can only specify one trigger configuration per source action.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitconfiguration.html#cfn-codepipeline-pipeline-gitconfiguration-sourceactionname
	//
	SourceActionName *string `field:"required" json:"sourceActionName" yaml:"sourceActionName"`
	// The field where the repository event that will start the pipeline is specified as pull requests.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitconfiguration.html#cfn-codepipeline-pipeline-gitconfiguration-pullrequest
	//
	PullRequest interface{} `field:"optional" json:"pullRequest" yaml:"pullRequest"`
	// The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitconfiguration.html#cfn-codepipeline-pipeline-gitconfiguration-push
	//
	Push interface{} `field:"optional" json:"push" yaml:"push"`
}

A type of trigger configuration for Git-based source actions.

> You can specify the Git configuration trigger type for all third-party Git-based source actions that are supported by the `CodeStarSourceConnection` action type.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

gitConfigurationProperty := &GitConfigurationProperty{
	SourceActionName: jsii.String("sourceActionName"),

	// the properties below are optional
	PullRequest: []interface{}{
		&GitPullRequestFilterProperty{
			Branches: &GitBranchFilterCriteriaProperty{
				Excludes: []*string{
					jsii.String("excludes"),
				},
				Includes: []*string{
					jsii.String("includes"),
				},
			},
			Events: []*string{
				jsii.String("events"),
			},
			FilePaths: &GitFilePathFilterCriteriaProperty{
				Excludes: []*string{
					jsii.String("excludes"),
				},
				Includes: []*string{
					jsii.String("includes"),
				},
			},
		},
	},
	Push: []interface{}{
		&GitPushFilterProperty{
			Branches: &GitBranchFilterCriteriaProperty{
				Excludes: []*string{
					jsii.String("excludes"),
				},
				Includes: []*string{
					jsii.String("includes"),
				},
			},
			FilePaths: &GitFilePathFilterCriteriaProperty{
				Excludes: []*string{
					jsii.String("excludes"),
				},
				Includes: []*string{
					jsii.String("includes"),
				},
			},
			Tags: &GitTagFilterCriteriaProperty{
				Excludes: []*string{
					jsii.String("excludes"),
				},
				Includes: []*string{
					jsii.String("includes"),
				},
			},
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitconfiguration.html

type CfnPipeline_GitFilePathFilterCriteriaProperty

type CfnPipeline_GitFilePathFilterCriteriaProperty struct {
	// The list of patterns of Git repository file paths that, when a commit is pushed, are to be excluded from starting the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html#cfn-codepipeline-pipeline-gitfilepathfiltercriteria-excludes
	//
	Excludes *[]*string `field:"optional" json:"excludes" yaml:"excludes"`
	// The list of patterns of Git repository file paths that, when a commit is pushed, are to be included as criteria that starts the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html#cfn-codepipeline-pipeline-gitfilepathfiltercriteria-includes
	//
	Includes *[]*string `field:"optional" json:"includes" yaml:"includes"`
}

The Git repository file paths specified as filter criteria to start the pipeline.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

gitFilePathFilterCriteriaProperty := &GitFilePathFilterCriteriaProperty{
	Excludes: []*string{
		jsii.String("excludes"),
	},
	Includes: []*string{
		jsii.String("includes"),
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitfilepathfiltercriteria.html

type CfnPipeline_GitPullRequestFilterProperty

type CfnPipeline_GitPullRequestFilterProperty struct {
	// The field that specifies to filter on branches for the pull request trigger configuration.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpullrequestfilter.html#cfn-codepipeline-pipeline-gitpullrequestfilter-branches
	//
	Branches interface{} `field:"optional" json:"branches" yaml:"branches"`
	// The field that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpullrequestfilter.html#cfn-codepipeline-pipeline-gitpullrequestfilter-events
	//
	Events *[]*string `field:"optional" json:"events" yaml:"events"`
	// The field that specifies to filter on file paths for the pull request trigger configuration.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpullrequestfilter.html#cfn-codepipeline-pipeline-gitpullrequestfilter-filepaths
	//
	FilePaths interface{} `field:"optional" json:"filePaths" yaml:"filePaths"`
}

The event criteria for the pull request trigger configuration, such as the lists of branches or file paths to include and exclude.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

gitPullRequestFilterProperty := &GitPullRequestFilterProperty{
	Branches: &GitBranchFilterCriteriaProperty{
		Excludes: []*string{
			jsii.String("excludes"),
		},
		Includes: []*string{
			jsii.String("includes"),
		},
	},
	Events: []*string{
		jsii.String("events"),
	},
	FilePaths: &GitFilePathFilterCriteriaProperty{
		Excludes: []*string{
			jsii.String("excludes"),
		},
		Includes: []*string{
			jsii.String("includes"),
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpullrequestfilter.html

type CfnPipeline_GitPushFilterProperty

type CfnPipeline_GitPushFilterProperty struct {
	// The field that specifies to filter on branches for the push trigger configuration.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html#cfn-codepipeline-pipeline-gitpushfilter-branches
	//
	Branches interface{} `field:"optional" json:"branches" yaml:"branches"`
	// The field that specifies to filter on file paths for the push trigger configuration.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html#cfn-codepipeline-pipeline-gitpushfilter-filepaths
	//
	FilePaths interface{} `field:"optional" json:"filePaths" yaml:"filePaths"`
	// The field that contains the details for the Git tags trigger configuration.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html#cfn-codepipeline-pipeline-gitpushfilter-tags
	//
	Tags *CfnPipeline_GitTagFilterCriteriaProperty `field:"optional" json:"tags" yaml:"tags"`
}

The event criteria that specify when a specified repository event will start the pipeline for the specified trigger configuration, such as the lists of Git tags to include and exclude.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

gitPushFilterProperty := &GitPushFilterProperty{
	Branches: &GitBranchFilterCriteriaProperty{
		Excludes: []*string{
			jsii.String("excludes"),
		},
		Includes: []*string{
			jsii.String("includes"),
		},
	},
	FilePaths: &GitFilePathFilterCriteriaProperty{
		Excludes: []*string{
			jsii.String("excludes"),
		},
		Includes: []*string{
			jsii.String("includes"),
		},
	},
	Tags: &GitTagFilterCriteriaProperty{
		Excludes: []*string{
			jsii.String("excludes"),
		},
		Includes: []*string{
			jsii.String("includes"),
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gitpushfilter.html

type CfnPipeline_GitTagFilterCriteriaProperty

type CfnPipeline_GitTagFilterCriteriaProperty struct {
	// The list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html#cfn-codepipeline-pipeline-gittagfiltercriteria-excludes
	//
	Excludes *[]*string `field:"optional" json:"excludes" yaml:"excludes"`
	// The list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html#cfn-codepipeline-pipeline-gittagfiltercriteria-includes
	//
	Includes *[]*string `field:"optional" json:"includes" yaml:"includes"`
}

The Git tags specified as filter criteria for whether a Git tag repository event will start the pipeline.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

gitTagFilterCriteriaProperty := &GitTagFilterCriteriaProperty{
	Excludes: []*string{
		jsii.String("excludes"),
	},
	Includes: []*string{
		jsii.String("includes"),
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-gittagfiltercriteria.html

type CfnPipeline_InputArtifactProperty

type CfnPipeline_InputArtifactProperty struct {
	// The name of the artifact to be worked on (for example, "My App").
	//
	// Artifacts are the files that are worked on by actions in the pipeline. See the action configuration for each action for details about artifact parameters. For example, the S3 source action input artifact is a file name (or file path), and the files are generally provided as a ZIP file. Example artifact name: SampleApp_Windows.zip
	//
	// The input artifact of an action must exactly match the output artifact declared in a preceding action, but the input artifact does not have to be the next action in strict sequence from the action that provided the output artifact. Actions in parallel can declare different output artifacts, which are in turn consumed by different following actions.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-inputartifact.html#cfn-codepipeline-pipeline-inputartifact-name
	//
	Name *string `field:"required" json:"name" yaml:"name"`
}

Represents information about an artifact to be worked on, such as a test or build artifact.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

inputArtifactProperty := &InputArtifactProperty{
	Name: jsii.String("name"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-inputartifact.html

type CfnPipeline_OutputArtifactProperty

type CfnPipeline_OutputArtifactProperty struct {
	// The name of the output of an artifact, such as "My App".
	//
	// The output artifact name must exactly match the input artifact declared for a downstream action. However, the downstream action's input artifact does not have to be the next action in strict sequence from the action that provided the output artifact. Actions in parallel can declare different output artifacts, which are in turn consumed by different following actions.
	//
	// Output artifact names must be unique within a pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-outputartifact.html#cfn-codepipeline-pipeline-outputartifact-name
	//
	Name *string `field:"required" json:"name" yaml:"name"`
}

Represents information about the output of an action.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

outputArtifactProperty := &OutputArtifactProperty{
	Name: jsii.String("name"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-outputartifact.html

type CfnPipeline_PipelineTriggerDeclarationProperty

type CfnPipeline_PipelineTriggerDeclarationProperty struct {
	// The source provider for the event, such as connections configured for a repository with Git tags, for the specified trigger configuration.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-pipelinetriggerdeclaration.html#cfn-codepipeline-pipeline-pipelinetriggerdeclaration-providertype
	//
	ProviderType *string `field:"required" json:"providerType" yaml:"providerType"`
	// Provides the filter criteria and the source stage for the repository event that starts the pipeline, such as Git tags.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-pipelinetriggerdeclaration.html#cfn-codepipeline-pipeline-pipelinetriggerdeclaration-gitconfiguration
	//
	GitConfiguration interface{} `field:"optional" json:"gitConfiguration" yaml:"gitConfiguration"`
}

Represents information about the specified trigger configuration, such as the filter criteria and the source stage for the action that contains the trigger.

> This is only supported for the `CodeStarSourceConnection` action type. > When a trigger configuration is specified, default change detection for repository and branch commits is disabled.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

pipelineTriggerDeclarationProperty := &PipelineTriggerDeclarationProperty{
	ProviderType: jsii.String("providerType"),

	// the properties below are optional
	GitConfiguration: &GitConfigurationProperty{
		SourceActionName: jsii.String("sourceActionName"),

		// the properties below are optional
		PullRequest: []interface{}{
			&GitPullRequestFilterProperty{
				Branches: &GitBranchFilterCriteriaProperty{
					Excludes: []*string{
						jsii.String("excludes"),
					},
					Includes: []*string{
						jsii.String("includes"),
					},
				},
				Events: []*string{
					jsii.String("events"),
				},
				FilePaths: &GitFilePathFilterCriteriaProperty{
					Excludes: []*string{
						jsii.String("excludes"),
					},
					Includes: []*string{
						jsii.String("includes"),
					},
				},
			},
		},
		Push: []interface{}{
			&GitPushFilterProperty{
				Branches: &GitBranchFilterCriteriaProperty{
					Excludes: []*string{
						jsii.String("excludes"),
					},
					Includes: []*string{
						jsii.String("includes"),
					},
				},
				FilePaths: &GitFilePathFilterCriteriaProperty{
					Excludes: []*string{
						jsii.String("excludes"),
					},
					Includes: []*string{
						jsii.String("includes"),
					},
				},
				Tags: &GitTagFilterCriteriaProperty{
					Excludes: []*string{
						jsii.String("excludes"),
					},
					Includes: []*string{
						jsii.String("includes"),
					},
				},
			},
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-pipelinetriggerdeclaration.html

type CfnPipeline_RuleDeclarationProperty

type CfnPipeline_RuleDeclarationProperty struct {
	// The action configuration fields for the rule.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruledeclaration.html#cfn-codepipeline-pipeline-ruledeclaration-configuration
	//
	Configuration interface{} `field:"optional" json:"configuration" yaml:"configuration"`
	// The input artifacts fields for the rule, such as specifying an input file for the rule.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruledeclaration.html#cfn-codepipeline-pipeline-ruledeclaration-inputartifacts
	//
	InputArtifacts interface{} `field:"optional" json:"inputArtifacts" yaml:"inputArtifacts"`
	// The name of the rule that is created for the condition, such as CheckAllResults.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruledeclaration.html#cfn-codepipeline-pipeline-ruledeclaration-name
	//
	Name *string `field:"optional" json:"name" yaml:"name"`
	// The Region for the condition associated with the rule.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruledeclaration.html#cfn-codepipeline-pipeline-ruledeclaration-region
	//
	Region *string `field:"optional" json:"region" yaml:"region"`
	// The pipeline role ARN associated with the rule.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruledeclaration.html#cfn-codepipeline-pipeline-ruledeclaration-rolearn
	//
	RoleArn *string `field:"optional" json:"roleArn" yaml:"roleArn"`
	// The ID for the rule type, which is made up of the combined values for category, owner, provider, and version.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruledeclaration.html#cfn-codepipeline-pipeline-ruledeclaration-ruletypeid
	//
	RuleTypeId interface{} `field:"optional" json:"ruleTypeId" yaml:"ruleTypeId"`
}

Represents information about the rule to be created for an associated condition.

An example would be creating a new rule for an entry condition, such as a rule that checks for a test result before allowing the run to enter the deployment stage.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

ruleDeclarationProperty := &RuleDeclarationProperty{
	Configuration: configuration,
	InputArtifacts: []interface{}{
		&InputArtifactProperty{
			Name: jsii.String("name"),
		},
	},
	Name: jsii.String("name"),
	Region: jsii.String("region"),
	RoleArn: jsii.String("roleArn"),
	RuleTypeId: &RuleTypeIdProperty{
		Category: jsii.String("category"),
		Owner: jsii.String("owner"),
		Provider: jsii.String("provider"),
		Version: jsii.String("version"),
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruledeclaration.html

type CfnPipeline_RuleTypeIdProperty

type CfnPipeline_RuleTypeIdProperty struct {
	// A category defines what kind of rule can be run in the stage, and constrains the provider type for the rule.
	//
	// The valid category is `Rule` .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruletypeid.html#cfn-codepipeline-pipeline-ruletypeid-category
	//
	Category *string `field:"optional" json:"category" yaml:"category"`
	// The creator of the rule being called.
	//
	// The valid value for the `Owner` field in the rule category is `AWS` .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruletypeid.html#cfn-codepipeline-pipeline-ruletypeid-owner
	//
	Owner *string `field:"optional" json:"owner" yaml:"owner"`
	// The rule provider, such as the `DeploymentWindow` rule.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruletypeid.html#cfn-codepipeline-pipeline-ruletypeid-provider
	//
	Provider *string `field:"optional" json:"provider" yaml:"provider"`
	// A string that describes the rule version.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruletypeid.html#cfn-codepipeline-pipeline-ruletypeid-version
	//
	Version *string `field:"optional" json:"version" yaml:"version"`
}

The ID for the rule type, which is made up of the combined values for category, owner, provider, and version.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

ruleTypeIdProperty := &RuleTypeIdProperty{
	Category: jsii.String("category"),
	Owner: jsii.String("owner"),
	Provider: jsii.String("provider"),
	Version: jsii.String("version"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-ruletypeid.html

type CfnPipeline_StageDeclarationProperty

type CfnPipeline_StageDeclarationProperty struct {
	// The actions included in a stage.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagedeclaration.html#cfn-codepipeline-pipeline-stagedeclaration-actions
	//
	Actions interface{} `field:"required" json:"actions" yaml:"actions"`
	// The name of the stage.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagedeclaration.html#cfn-codepipeline-pipeline-stagedeclaration-name
	//
	Name *string `field:"required" json:"name" yaml:"name"`
	// The method to use when a stage allows entry.
	//
	// For example, configuring this field for conditions will allow entry to the stage when the conditions are met.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagedeclaration.html#cfn-codepipeline-pipeline-stagedeclaration-beforeentry
	//
	BeforeEntry interface{} `field:"optional" json:"beforeEntry" yaml:"beforeEntry"`
	// Reserved for future use.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagedeclaration.html#cfn-codepipeline-pipeline-stagedeclaration-blockers
	//
	Blockers interface{} `field:"optional" json:"blockers" yaml:"blockers"`
	// The method to use when a stage has not completed successfully.
	//
	// For example, configuring this field for rollback will roll back a failed stage automatically to the last successful pipeline execution in the stage.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagedeclaration.html#cfn-codepipeline-pipeline-stagedeclaration-onfailure
	//
	OnFailure interface{} `field:"optional" json:"onFailure" yaml:"onFailure"`
	// The method to use when a stage has succeeded.
	//
	// For example, configuring this field for conditions will allow the stage to succeed when the conditions are met.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagedeclaration.html#cfn-codepipeline-pipeline-stagedeclaration-onsuccess
	//
	OnSuccess interface{} `field:"optional" json:"onSuccess" yaml:"onSuccess"`
}

Represents information about a stage and its definition.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

stageDeclarationProperty := &StageDeclarationProperty{
	Actions: []interface{}{
		&ActionDeclarationProperty{
			ActionTypeId: &ActionTypeIdProperty{
				Category: jsii.String("category"),
				Owner: jsii.String("owner"),
				Provider: jsii.String("provider"),
				Version: jsii.String("version"),
			},
			Name: jsii.String("name"),

			// the properties below are optional
			Configuration: configuration,
			InputArtifacts: []interface{}{
				&InputArtifactProperty{
					Name: jsii.String("name"),
				},
			},
			Namespace: jsii.String("namespace"),
			OutputArtifacts: []interface{}{
				&OutputArtifactProperty{
					Name: jsii.String("name"),
				},
			},
			Region: jsii.String("region"),
			RoleArn: jsii.String("roleArn"),
			RunOrder: jsii.Number(123),
			TimeoutInMinutes: jsii.Number(123),
		},
	},
	Name: jsii.String("name"),

	// the properties below are optional
	BeforeEntry: &BeforeEntryConditionsProperty{
		Conditions: []interface{}{
			&ConditionProperty{
				Result: jsii.String("result"),
				Rules: []interface{}{
					&RuleDeclarationProperty{
						Configuration: configuration,
						InputArtifacts: []interface{}{
							&InputArtifactProperty{
								Name: jsii.String("name"),
							},
						},
						Name: jsii.String("name"),
						Region: jsii.String("region"),
						RoleArn: jsii.String("roleArn"),
						RuleTypeId: &RuleTypeIdProperty{
							Category: jsii.String("category"),
							Owner: jsii.String("owner"),
							Provider: jsii.String("provider"),
							Version: jsii.String("version"),
						},
					},
				},
			},
		},
	},
	Blockers: []interface{}{
		&BlockerDeclarationProperty{
			Name: jsii.String("name"),
			Type: jsii.String("type"),
		},
	},
	OnFailure: &FailureConditionsProperty{
		Conditions: []interface{}{
			&ConditionProperty{
				Result: jsii.String("result"),
				Rules: []interface{}{
					&RuleDeclarationProperty{
						Configuration: configuration,
						InputArtifacts: []interface{}{
							&InputArtifactProperty{
								Name: jsii.String("name"),
							},
						},
						Name: jsii.String("name"),
						Region: jsii.String("region"),
						RoleArn: jsii.String("roleArn"),
						RuleTypeId: &RuleTypeIdProperty{
							Category: jsii.String("category"),
							Owner: jsii.String("owner"),
							Provider: jsii.String("provider"),
							Version: jsii.String("version"),
						},
					},
				},
			},
		},
		Result: jsii.String("result"),
	},
	OnSuccess: &SuccessConditionsProperty{
		Conditions: []interface{}{
			&ConditionProperty{
				Result: jsii.String("result"),
				Rules: []interface{}{
					&RuleDeclarationProperty{
						Configuration: configuration,
						InputArtifacts: []interface{}{
							&InputArtifactProperty{
								Name: jsii.String("name"),
							},
						},
						Name: jsii.String("name"),
						Region: jsii.String("region"),
						RoleArn: jsii.String("roleArn"),
						RuleTypeId: &RuleTypeIdProperty{
							Category: jsii.String("category"),
							Owner: jsii.String("owner"),
							Provider: jsii.String("provider"),
							Version: jsii.String("version"),
						},
					},
				},
			},
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagedeclaration.html

type CfnPipeline_StageTransitionProperty

type CfnPipeline_StageTransitionProperty struct {
	// The reason given to the user that a stage is disabled, such as waiting for manual approval or manual tests.
	//
	// This message is displayed in the pipeline console UI.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagetransition.html#cfn-codepipeline-pipeline-stagetransition-reason
	//
	Reason *string `field:"required" json:"reason" yaml:"reason"`
	// The name of the stage where you want to disable the inbound or outbound transition of artifacts.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagetransition.html#cfn-codepipeline-pipeline-stagetransition-stagename
	//
	StageName *string `field:"required" json:"stageName" yaml:"stageName"`
}

The name of the pipeline in which you want to disable the flow of artifacts from one stage to another.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

stageTransitionProperty := &StageTransitionProperty{
	Reason: jsii.String("reason"),
	StageName: jsii.String("stageName"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-stagetransition.html

type CfnPipeline_SuccessConditionsProperty

type CfnPipeline_SuccessConditionsProperty struct {
	// The conditions that are success conditions.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-successconditions.html#cfn-codepipeline-pipeline-successconditions-conditions
	//
	Conditions interface{} `field:"optional" json:"conditions" yaml:"conditions"`
}

The conditions for making checks that, if met, succeed a stage.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var configuration interface{}

successConditionsProperty := &SuccessConditionsProperty{
	Conditions: []interface{}{
		&ConditionProperty{
			Result: jsii.String("result"),
			Rules: []interface{}{
				&RuleDeclarationProperty{
					Configuration: configuration,
					InputArtifacts: []interface{}{
						&InputArtifactProperty{
							Name: jsii.String("name"),
						},
					},
					Name: jsii.String("name"),
					Region: jsii.String("region"),
					RoleArn: jsii.String("roleArn"),
					RuleTypeId: &RuleTypeIdProperty{
						Category: jsii.String("category"),
						Owner: jsii.String("owner"),
						Provider: jsii.String("provider"),
						Version: jsii.String("version"),
					},
				},
			},
		},
	},
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-successconditions.html

type CfnPipeline_VariableDeclarationProperty

type CfnPipeline_VariableDeclarationProperty struct {
	// The name of a pipeline-level variable.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-variabledeclaration.html#cfn-codepipeline-pipeline-variabledeclaration-name
	//
	Name *string `field:"required" json:"name" yaml:"name"`
	// The value of a pipeline-level variable.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-variabledeclaration.html#cfn-codepipeline-pipeline-variabledeclaration-defaultvalue
	//
	DefaultValue *string `field:"optional" json:"defaultValue" yaml:"defaultValue"`
	// The description of a pipeline-level variable.
	//
	// It's used to add additional context about the variable, and not being used at time when pipeline executes.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-variabledeclaration.html#cfn-codepipeline-pipeline-variabledeclaration-description
	//
	Description *string `field:"optional" json:"description" yaml:"description"`
}

A variable declared at the pipeline level.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

variableDeclarationProperty := &VariableDeclarationProperty{
	Name: jsii.String("name"),

	// the properties below are optional
	DefaultValue: jsii.String("defaultValue"),
	Description: jsii.String("description"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-pipeline-variabledeclaration.html

type CfnWebhook

type CfnWebhook interface {
	awscdk.CfnResource
	awscdk.IInspectable
	AttrId() *string
	// The webhook URL generated by AWS CodePipeline , such as `https://eu-central-1.webhooks.aws/trigger123456` .
	AttrUrl() *string
	// Supported options are GITHUB_HMAC, IP, and UNAUTHENTICATED.
	Authentication() *string
	SetAuthentication(val *string)
	// Properties that configure the authentication applied to incoming webhook trigger requests.
	AuthenticationConfiguration() interface{}
	SetAuthenticationConfiguration(val interface{})
	// Options for this resource, such as condition, update policy etc.
	CfnOptions() awscdk.ICfnResourceOptions
	CfnProperties() *map[string]interface{}
	// AWS resource type.
	CfnResourceType() *string
	// Returns: the stack trace of the point where this Resource was created from, sourced
	// from the +metadata+ entry typed +aws:cdk:logicalId+, and with the bottom-most
	// node +internal+ entries filtered.
	CreationStack() *[]*string
	// A list of rules applied to the body/payload sent in the POST request to a webhook URL.
	Filters() interface{}
	SetFilters(val interface{})
	// The logical ID for this CloudFormation stack element.
	//
	// The logical ID of the element
	// is calculated from the path of the resource node in the construct tree.
	//
	// To override this value, use `overrideLogicalId(newLogicalId)`.
	//
	// Returns: the logical ID as a stringified token. This value will only get
	// resolved during synthesis.
	LogicalId() *string
	// The name of the webhook.
	Name() *string
	SetName(val *string)
	// The tree node.
	Node() constructs.Node
	// Return a string that will be resolved to a CloudFormation `{ Ref }` for this element.
	//
	// If, by any chance, the intrinsic reference of a resource is not a string, you could
	// coerce it to an IResolvable through `Lazy.any({ produce: resource.ref })`.
	Ref() *string
	// Configures a connection between the webhook that was created and the external tool with events to be detected.
	RegisterWithThirdParty() interface{}
	SetRegisterWithThirdParty(val interface{})
	// The stack in which this element is defined.
	//
	// CfnElements must be defined within a stack scope (directly or indirectly).
	Stack() awscdk.Stack
	// The name of the action in a pipeline you want to connect to the webhook.
	TargetAction() *string
	SetTargetAction(val *string)
	// The name of the pipeline you want to connect to the webhook.
	TargetPipeline() *string
	SetTargetPipeline(val *string)
	// The version number of the pipeline to be connected to the trigger request.
	TargetPipelineVersion() *float64
	SetTargetPipelineVersion(val *float64)
	// Deprecated.
	// Deprecated: use `updatedProperties`
	//
	// Return properties modified after initiation
	//
	// Resources that expose mutable properties should override this function to
	// collect and return the properties object for this resource.
	UpdatedProperites() *map[string]interface{}
	// Return properties modified after initiation.
	//
	// Resources that expose mutable properties should override this function to
	// collect and return the properties object for this resource.
	UpdatedProperties() *map[string]interface{}
	// Syntactic sugar for `addOverride(path, undefined)`.
	AddDeletionOverride(path *string)
	// Indicates that this resource depends on another resource and cannot be provisioned unless the other resource has been successfully provisioned.
	//
	// This can be used for resources across stacks (or nested stack) boundaries
	// and the dependency will automatically be transferred to the relevant scope.
	AddDependency(target awscdk.CfnResource)
	// Indicates that this resource depends on another resource and cannot be provisioned unless the other resource has been successfully provisioned.
	// Deprecated: use addDependency.
	AddDependsOn(target awscdk.CfnResource)
	// Add a value to the CloudFormation Resource Metadata.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html
	//
	// Note that this is a different set of metadata from CDK node metadata; this
	// metadata ends up in the stack template under the resource, whereas CDK
	// node metadata ends up in the Cloud Assembly.
	//
	AddMetadata(key *string, value interface{})
	// Adds an override to the synthesized CloudFormation resource.
	//
	// To add a
	// property override, either use `addPropertyOverride` or prefix `path` with
	// "Properties." (i.e. `Properties.TopicName`).
	//
	// If the override is nested, separate each nested level using a dot (.) in the path parameter.
	// If there is an array as part of the nesting, specify the index in the path.
	//
	// To include a literal `.` in the property name, prefix with a `\`. In most
	// programming languages you will need to write this as `"\\."` because the
	// `\` itself will need to be escaped.
	//
	// For example,
	// “`typescript
	// cfnResource.addOverride('Properties.GlobalSecondaryIndexes.0.Projection.NonKeyAttributes', ['myattribute']);
	// cfnResource.addOverride('Properties.GlobalSecondaryIndexes.1.ProjectionType', 'INCLUDE');
	// “`
	// would add the overrides
	// “`json
	// "Properties": {
	//   "GlobalSecondaryIndexes": [
	//     {
	//       "Projection": {
	//         "NonKeyAttributes": [ "myattribute" ]
	//         ...
	//       }
	//       ...
	//     },
	//     {
	//       "ProjectionType": "INCLUDE"
	//       ...
	//     },
	//   ]
	//   ...
	// }
	// “`
	//
	// The `value` argument to `addOverride` will not be processed or translated
	// in any way. Pass raw JSON values in here with the correct capitalization
	// for CloudFormation. If you pass CDK classes or structs, they will be
	// rendered with lowercased key names, and CloudFormation will reject the
	// template.
	AddOverride(path *string, value interface{})
	// Adds an override that deletes the value of a property from the resource definition.
	AddPropertyDeletionOverride(propertyPath *string)
	// Adds an override to a resource property.
	//
	// Syntactic sugar for `addOverride("Properties.<...>", value)`.
	AddPropertyOverride(propertyPath *string, value interface{})
	// Sets the deletion policy of the resource based on the removal policy specified.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`). In some
	// cases, a snapshot can be taken of the resource prior to deletion
	// (`RemovalPolicy.SNAPSHOT`). A list of resources that support this policy
	// can be found in the following link:.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-attribute-deletionpolicy.html#aws-attribute-deletionpolicy-options
	//
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy, options *awscdk.RemovalPolicyOptions)
	// Returns a token for an runtime attribute of this resource.
	//
	// Ideally, use generated attribute accessors (e.g. `resource.arn`), but this can be used for future compatibility
	// in case there is no generated attribute.
	GetAtt(attributeName *string, typeHint awscdk.ResolutionTypeHint) awscdk.Reference
	// Retrieve a value value from the CloudFormation Resource Metadata.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/metadata-section-structure.html
	//
	// Note that this is a different set of metadata from CDK node metadata; this
	// metadata ends up in the stack template under the resource, whereas CDK
	// node metadata ends up in the Cloud Assembly.
	//
	GetMetadata(key *string) interface{}
	// Examines the CloudFormation resource and discloses attributes.
	Inspect(inspector awscdk.TreeInspector)
	// Retrieves an array of resources this resource depends on.
	//
	// This assembles dependencies on resources across stacks (including nested stacks)
	// automatically.
	ObtainDependencies() *[]interface{}
	// Get a shallow copy of dependencies between this resource and other resources in the same stack.
	ObtainResourceDependencies() *[]awscdk.CfnResource
	// Overrides the auto-generated logical ID with a specific ID.
	OverrideLogicalId(newLogicalId *string)
	// Indicates that this resource no longer depends on another resource.
	//
	// This can be used for resources across stacks (including nested stacks)
	// and the dependency will automatically be removed from the relevant scope.
	RemoveDependency(target awscdk.CfnResource)
	RenderProperties(props *map[string]interface{}) *map[string]interface{}
	// Replaces one dependency with another.
	ReplaceDependency(target awscdk.CfnResource, newTarget awscdk.CfnResource)
	// Can be overridden by subclasses to determine if this resource will be rendered into the cloudformation template.
	//
	// Returns: `true` if the resource should be included or `false` is the resource
	// should be omitted.
	ShouldSynthesize() *bool
	// Returns a string representation of this construct.
	//
	// Returns: a string representation of this resource.
	ToString() *string
	ValidateProperties(_properties interface{})
}

The `AWS::CodePipeline::Webhook` resource creates and registers your webhook.

After the webhook is created and registered, it triggers your pipeline to start every time an external event occurs. For more information, see [Migrate polling pipelines to use event-based change detection](https://docs.aws.amazon.com/codepipeline/latest/userguide/update-change-detection.html) in the *AWS CodePipeline User Guide* .

We strongly recommend that you use AWS Secrets Manager to store your credentials. If you use Secrets Manager, you must have already configured and stored your secret parameters in Secrets Manager. For more information, see [Using Dynamic References to Specify Template Values](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html#dynamic-references-secretsmanager) .

> When passing secret parameters, do not enter the value directly into the template. The value is rendered as plaintext and is therefore readable. For security reasons, do not use plaintext in your AWS CloudFormation template to store your credentials.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

cfnWebhook := awscdk.Aws_codepipeline.NewCfnWebhook(this, jsii.String("MyCfnWebhook"), &CfnWebhookProps{
	Authentication: jsii.String("authentication"),
	AuthenticationConfiguration: &WebhookAuthConfigurationProperty{
		AllowedIpRange: jsii.String("allowedIpRange"),
		SecretToken: jsii.String("secretToken"),
	},
	Filters: []interface{}{
		&WebhookFilterRuleProperty{
			JsonPath: jsii.String("jsonPath"),

			// the properties below are optional
			MatchEquals: jsii.String("matchEquals"),
		},
	},
	TargetAction: jsii.String("targetAction"),
	TargetPipeline: jsii.String("targetPipeline"),
	TargetPipelineVersion: jsii.Number(123),

	// the properties below are optional
	Name: jsii.String("name"),
	RegisterWithThirdParty: jsii.Boolean(false),
})

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html

func NewCfnWebhook

func NewCfnWebhook(scope constructs.Construct, id *string, props *CfnWebhookProps) CfnWebhook

type CfnWebhookProps

type CfnWebhookProps struct {
	// Supported options are GITHUB_HMAC, IP, and UNAUTHENTICATED.
	//
	// > When creating CodePipeline webhooks, do not use your own credentials or reuse the same secret token across multiple webhooks. For optimal security, generate a unique secret token for each webhook you create. The secret token is an arbitrary string that you provide, which GitHub uses to compute and sign the webhook payloads sent to CodePipeline, for protecting the integrity and authenticity of the webhook payloads. Using your own credentials or reusing the same token across multiple webhooks can lead to security vulnerabilities. > If a secret token was provided, it will be redacted in the response.
	//
	// - For information about the authentication scheme implemented by GITHUB_HMAC, see [Securing your webhooks](https://docs.aws.amazon.com/https://developer.github.com/webhooks/securing/) on the GitHub Developer website.
	// - IP rejects webhooks trigger requests unless they originate from an IP address in the IP range whitelisted in the authentication configuration.
	// - UNAUTHENTICATED accepts all webhook trigger requests regardless of origin.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html#cfn-codepipeline-webhook-authentication
	//
	Authentication *string `field:"required" json:"authentication" yaml:"authentication"`
	// Properties that configure the authentication applied to incoming webhook trigger requests.
	//
	// The required properties depend on the authentication type. For GITHUB_HMAC, only the `SecretToken` property must be set. For IP, only the `AllowedIPRange` property must be set to a valid CIDR range. For UNAUTHENTICATED, no properties can be set.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html#cfn-codepipeline-webhook-authenticationconfiguration
	//
	AuthenticationConfiguration interface{} `field:"required" json:"authenticationConfiguration" yaml:"authenticationConfiguration"`
	// A list of rules applied to the body/payload sent in the POST request to a webhook URL.
	//
	// All defined rules must pass for the request to be accepted and the pipeline started.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html#cfn-codepipeline-webhook-filters
	//
	Filters interface{} `field:"required" json:"filters" yaml:"filters"`
	// The name of the action in a pipeline you want to connect to the webhook.
	//
	// The action must be from the source (first) stage of the pipeline.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html#cfn-codepipeline-webhook-targetaction
	//
	TargetAction *string `field:"required" json:"targetAction" yaml:"targetAction"`
	// The name of the pipeline you want to connect to the webhook.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html#cfn-codepipeline-webhook-targetpipeline
	//
	TargetPipeline *string `field:"required" json:"targetPipeline" yaml:"targetPipeline"`
	// The version number of the pipeline to be connected to the trigger request.
	//
	// Required: Yes
	//
	// Type: Integer
	//
	// Update requires: [No interruption](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-update-behaviors.html#update-no-interrupt)
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html#cfn-codepipeline-webhook-targetpipelineversion
	//
	TargetPipelineVersion *float64 `field:"required" json:"targetPipelineVersion" yaml:"targetPipelineVersion"`
	// The name of the webhook.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html#cfn-codepipeline-webhook-name
	//
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Configures a connection between the webhook that was created and the external tool with events to be detected.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html#cfn-codepipeline-webhook-registerwiththirdparty
	//
	RegisterWithThirdParty interface{} `field:"optional" json:"registerWithThirdParty" yaml:"registerWithThirdParty"`
}

Properties for defining a `CfnWebhook`.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

cfnWebhookProps := &CfnWebhookProps{
	Authentication: jsii.String("authentication"),
	AuthenticationConfiguration: &WebhookAuthConfigurationProperty{
		AllowedIpRange: jsii.String("allowedIpRange"),
		SecretToken: jsii.String("secretToken"),
	},
	Filters: []interface{}{
		&WebhookFilterRuleProperty{
			JsonPath: jsii.String("jsonPath"),

			// the properties below are optional
			MatchEquals: jsii.String("matchEquals"),
		},
	},
	TargetAction: jsii.String("targetAction"),
	TargetPipeline: jsii.String("targetPipeline"),
	TargetPipelineVersion: jsii.Number(123),

	// the properties below are optional
	Name: jsii.String("name"),
	RegisterWithThirdParty: jsii.Boolean(false),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-webhook.html

type CfnWebhook_WebhookAuthConfigurationProperty

type CfnWebhook_WebhookAuthConfigurationProperty struct {
	// The property used to configure acceptance of webhooks in an IP address range.
	//
	// For IP, only the `AllowedIPRange` property must be set. This property must be set to a valid CIDR range.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-webhook-webhookauthconfiguration.html#cfn-codepipeline-webhook-webhookauthconfiguration-allowediprange
	//
	AllowedIpRange *string `field:"optional" json:"allowedIpRange" yaml:"allowedIpRange"`
	// The property used to configure GitHub authentication. For GITHUB_HMAC, only the `SecretToken` property must be set.
	//
	// > When creating CodePipeline webhooks, do not use your own credentials or reuse the same secret token across multiple webhooks. For optimal security, generate a unique secret token for each webhook you create. The secret token is an arbitrary string that you provide, which GitHub uses to compute and sign the webhook payloads sent to CodePipeline, for protecting the integrity and authenticity of the webhook payloads. Using your own credentials or reusing the same token across multiple webhooks can lead to security vulnerabilities. > If a secret token was provided, it will be redacted in the response.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-webhook-webhookauthconfiguration.html#cfn-codepipeline-webhook-webhookauthconfiguration-secrettoken
	//
	SecretToken *string `field:"optional" json:"secretToken" yaml:"secretToken"`
}

The authentication applied to incoming webhook trigger requests.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

webhookAuthConfigurationProperty := &WebhookAuthConfigurationProperty{
	AllowedIpRange: jsii.String("allowedIpRange"),
	SecretToken: jsii.String("secretToken"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-webhook-webhookauthconfiguration.html

type CfnWebhook_WebhookFilterRuleProperty

type CfnWebhook_WebhookFilterRuleProperty struct {
	// A JsonPath expression that is applied to the body/payload of the webhook.
	//
	// The value selected by the JsonPath expression must match the value specified in the `MatchEquals` field. Otherwise, the request is ignored. For more information, see [Java JsonPath implementation](https://docs.aws.amazon.com/https://github.com/json-path/JsonPath) in GitHub.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-webhook-webhookfilterrule.html#cfn-codepipeline-webhook-webhookfilterrule-jsonpath
	//
	JsonPath *string `field:"required" json:"jsonPath" yaml:"jsonPath"`
	// The value selected by the `JsonPath` expression must match what is supplied in the `MatchEquals` field.
	//
	// Otherwise, the request is ignored. Properties from the target action configuration can be included as placeholders in this value by surrounding the action configuration key with curly brackets. For example, if the value supplied here is "refs/heads/{Branch}" and the target action has an action configuration property called "Branch" with a value of "main", the `MatchEquals` value is evaluated as "refs/heads/main". For a list of action configuration properties for built-in action types, see [Pipeline Structure Reference Action Requirements](https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html#action-requirements) .
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-webhook-webhookfilterrule.html#cfn-codepipeline-webhook-webhookfilterrule-matchequals
	//
	MatchEquals *string `field:"optional" json:"matchEquals" yaml:"matchEquals"`
}

The event criteria that specify when a webhook notification is sent to your URL.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

webhookFilterRuleProperty := &WebhookFilterRuleProperty{
	JsonPath: jsii.String("jsonPath"),

	// the properties below are optional
	MatchEquals: jsii.String("matchEquals"),
}

See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codepipeline-webhook-webhookfilterrule.html

type CommonActionProps

type CommonActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `field:"required" json:"actionName" yaml:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	// Default: 1.
	//
	RunOrder *float64 `field:"optional" json:"runOrder" yaml:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	// Default: - a name will be generated, based on the stage and action names,
	// if any of the action's variables were referenced - otherwise,
	// no namespace will be set.
	//
	VariablesNamespace *string `field:"optional" json:"variablesNamespace" yaml:"variablesNamespace"`
}

Common properties shared by all Actions.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

commonActionProps := &CommonActionProps{
	ActionName: jsii.String("actionName"),

	// the properties below are optional
	RunOrder: jsii.Number(123),
	VariablesNamespace: jsii.String("variablesNamespace"),
}

type CommonAwsActionProps

type CommonAwsActionProps struct {
	// The physical, human-readable name of the Action.
	//
	// Note that Action names must be unique within a single Stage.
	ActionName *string `field:"required" json:"actionName" yaml:"actionName"`
	// The runOrder property for this Action.
	//
	// RunOrder determines the relative order in which multiple Actions in the same Stage execute.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/reference-pipeline-structure.html
	//
	// Default: 1.
	//
	RunOrder *float64 `field:"optional" json:"runOrder" yaml:"runOrder"`
	// The name of the namespace to use for variables emitted by this action.
	// Default: - a name will be generated, based on the stage and action names,
	// if any of the action's variables were referenced - otherwise,
	// no namespace will be set.
	//
	VariablesNamespace *string `field:"optional" json:"variablesNamespace" yaml:"variablesNamespace"`
	// The Role in which context's this Action will be executing in.
	//
	// The Pipeline's Role will assume this Role
	// (the required permissions for that will be granted automatically)
	// right before executing this Action.
	// This Action will be passed into your `IAction.bind`
	// method in the `ActionBindOptions.role` property.
	// Default: a new Role will be generated.
	//
	Role awsiam.IRole `field:"optional" json:"role" yaml:"role"`
}

Common properties shared by all Actions whose `ActionProperties.owner` field is 'AWS' (or unset, as 'AWS' is the default).

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var role role

commonAwsActionProps := &CommonAwsActionProps{
	ActionName: jsii.String("actionName"),

	// the properties below are optional
	Role: role,
	RunOrder: jsii.Number(123),
	VariablesNamespace: jsii.String("variablesNamespace"),
}

type CrossRegionSupport

type CrossRegionSupport struct {
	// The replication Bucket used by CodePipeline to operate in this region.
	//
	// Belongs to `stack`.
	ReplicationBucket awss3.IBucket `field:"required" json:"replicationBucket" yaml:"replicationBucket"`
	// The Stack that has been created to house the replication Bucket required for this  region.
	Stack awscdk.Stack `field:"required" json:"stack" yaml:"stack"`
}

An interface representing resources generated in order to support the cross-region capabilities of CodePipeline.

You get instances of this interface from the `Pipeline#crossRegionSupport` property.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import cdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

var bucket bucket
var stack stack

crossRegionSupport := &CrossRegionSupport{
	ReplicationBucket: bucket,
	Stack: stack,
}

type CustomActionProperty

type CustomActionProperty struct {
	// The name of the property.
	//
	// You use this name in the `configuration` attribute when defining your custom Action class.
	Name *string `field:"required" json:"name" yaml:"name"`
	// Whether this property is required.
	Required *bool `field:"required" json:"required" yaml:"required"`
	// The description of the property.
	// Default: the description will be empty.
	//
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Whether this property is a key.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-key
	//
	// Default: false.
	//
	Key *bool `field:"optional" json:"key" yaml:"key"`
	// Whether this property is queryable.
	//
	// Note that only a single property of a custom Action can be queryable.
	// See: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codepipeline-customactiontype-configurationproperties.html#cfn-codepipeline-customactiontype-configurationproperties-queryable
	//
	// Default: false.
	//
	Queryable *bool `field:"optional" json:"queryable" yaml:"queryable"`
	// Whether this property is secret, like a password, or access key.
	// Default: false.
	//
	Secret *bool `field:"optional" json:"secret" yaml:"secret"`
	// The type of the property, like 'String', 'Number', or 'Boolean'.
	// Default: 'String'.
	//
	Type *string `field:"optional" json:"type" yaml:"type"`
}

The creation attributes used for defining a configuration property of a custom Action.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

customActionProperty := &CustomActionProperty{
	Name: jsii.String("name"),
	Required: jsii.Boolean(false),

	// the properties below are optional
	Description: jsii.String("description"),
	Key: jsii.Boolean(false),
	Queryable: jsii.Boolean(false),
	Secret: jsii.Boolean(false),
	Type: jsii.String("type"),
}

type CustomActionRegistration

type CustomActionRegistration interface {
	constructs.Construct
	// The tree node.
	Node() constructs.Node
	// Returns a string representation of this construct.
	ToString() *string
}

The resource representing registering a custom Action with CodePipeline.

For the Action to be usable, it has to be registered for every region and every account it's used in. In addition to this class, you should most likely also provide your clients a class representing your custom Action, extending the Action class, and taking the `actionProperties` as properly typed, construction properties.

Example:

// Make a custom CodePipeline Action
// Make a custom CodePipeline Action
codepipeline.NewCustomActionRegistration(this, jsii.String("GenericGitSourceProviderResource"), &CustomActionRegistrationProps{
	Category: codepipeline.ActionCategory_SOURCE,
	ArtifactBounds: &ActionArtifactBounds{
		MinInputs: jsii.Number(0),
		MaxInputs: jsii.Number(0),
		MinOutputs: jsii.Number(1),
		MaxOutputs: jsii.Number(1),
	},
	Provider: jsii.String("GenericGitSource"),
	Version: jsii.String("1"),
	EntityUrl: jsii.String("https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html"),
	ExecutionUrl: jsii.String("https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html"),
	ActionProperties: []customActionProperty{
		&customActionProperty{
			Name: jsii.String("Branch"),
			Required: jsii.Boolean(true),
			Key: jsii.Boolean(false),
			Secret: jsii.Boolean(false),
			Queryable: jsii.Boolean(false),
			Description: jsii.String("Git branch to pull"),
			Type: jsii.String("String"),
		},
		&customActionProperty{
			Name: jsii.String("GitUrl"),
			Required: jsii.Boolean(true),
			Key: jsii.Boolean(false),
			Secret: jsii.Boolean(false),
			Queryable: jsii.Boolean(false),
			Description: jsii.String("SSH git clone URL"),
			Type: jsii.String("String"),
		},
	},
})

func NewCustomActionRegistration

func NewCustomActionRegistration(scope constructs.Construct, id *string, props *CustomActionRegistrationProps) CustomActionRegistration

type CustomActionRegistrationProps

type CustomActionRegistrationProps struct {
	// The artifact bounds of the Action.
	ArtifactBounds *ActionArtifactBounds `field:"required" json:"artifactBounds" yaml:"artifactBounds"`
	// The category of the Action.
	Category ActionCategory `field:"required" json:"category" yaml:"category"`
	// The provider of the Action.
	//
	// For example, `'MyCustomActionProvider'`.
	Provider *string `field:"required" json:"provider" yaml:"provider"`
	// The properties used for customizing the instance of your Action.
	// Default: [].
	//
	ActionProperties *[]*CustomActionProperty `field:"optional" json:"actionProperties" yaml:"actionProperties"`
	// The URL shown for the entire Action in the Pipeline UI.
	// Default: none.
	//
	EntityUrl *string `field:"optional" json:"entityUrl" yaml:"entityUrl"`
	// The URL shown for a particular execution of an Action in the Pipeline UI.
	// Default: none.
	//
	ExecutionUrl *string `field:"optional" json:"executionUrl" yaml:"executionUrl"`
	// The version of your Action.
	// Default: '1'.
	//
	Version *string `field:"optional" json:"version" yaml:"version"`
}

Properties of registering a custom Action.

Example:

// Make a custom CodePipeline Action
// Make a custom CodePipeline Action
codepipeline.NewCustomActionRegistration(this, jsii.String("GenericGitSourceProviderResource"), &CustomActionRegistrationProps{
	Category: codepipeline.ActionCategory_SOURCE,
	ArtifactBounds: &ActionArtifactBounds{
		MinInputs: jsii.Number(0),
		MaxInputs: jsii.Number(0),
		MinOutputs: jsii.Number(1),
		MaxOutputs: jsii.Number(1),
	},
	Provider: jsii.String("GenericGitSource"),
	Version: jsii.String("1"),
	EntityUrl: jsii.String("https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html"),
	ExecutionUrl: jsii.String("https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-create-custom-action.html"),
	ActionProperties: []customActionProperty{
		&customActionProperty{
			Name: jsii.String("Branch"),
			Required: jsii.Boolean(true),
			Key: jsii.Boolean(false),
			Secret: jsii.Boolean(false),
			Queryable: jsii.Boolean(false),
			Description: jsii.String("Git branch to pull"),
			Type: jsii.String("String"),
		},
		&customActionProperty{
			Name: jsii.String("GitUrl"),
			Required: jsii.Boolean(true),
			Key: jsii.Boolean(false),
			Secret: jsii.Boolean(false),
			Queryable: jsii.Boolean(false),
			Description: jsii.String("SSH git clone URL"),
			Type: jsii.String("String"),
		},
	},
})

type ExecutionMode

type ExecutionMode string

Execution mode.

Example:

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	ExecutionMode: codepipeline.ExecutionMode_PARALLEL,
})

const (
	// QUEUED mode.
	//
	// Executions are processed one by one in the order that they are queued.
	//
	// This requires pipeline type V2.
	ExecutionMode_QUEUED ExecutionMode = "QUEUED"
	// SUPERSEDED mode.
	//
	// A more recent execution can overtake an older one.
	//
	// This is the default.
	ExecutionMode_SUPERSEDED ExecutionMode = "SUPERSEDED"
	// PARALLEL mode.
	//
	// In PARALLEL mode, executions run simultaneously and independently of one
	// another. Executions don't wait for other runs to complete before starting
	// or finishing.
	//
	// This requires pipeline type V2.
	ExecutionMode_PARALLEL ExecutionMode = "PARALLEL"
)

type GitConfiguration

type GitConfiguration struct {
	// The pipeline source action where the trigger configuration, such as Git tags.
	//
	// The trigger configuration will start the pipeline upon the specified change only.
	// You can only specify one trigger configuration per source action.
	//
	// Since the provider for `sourceAction` must be `CodeStarSourceConnection`, you can use
	// `CodeStarConnectionsSourceAction` construct in `aws-codepipeline-actions` module.
	SourceAction IAction `field:"required" json:"sourceAction" yaml:"sourceAction"`
	// The field where the repository event that will start the pipeline is specified as pull requests.
	//
	// The length must be less than or equal to 3.
	// Default: - no filter.
	//
	PullRequestFilter *[]*GitPullRequestFilter `field:"optional" json:"pullRequestFilter" yaml:"pullRequestFilter"`
	// The field where the repository event that will start the pipeline, such as pushing Git tags, is specified with details.
	//
	// Git tags is the only supported event type.
	//
	// The length must be less than or equal to 3.
	// Default: - no filter.
	//
	PushFilter *[]*GitPushFilter `field:"optional" json:"pushFilter" yaml:"pushFilter"`
}

Git configuration for trigger.

Example:

var sourceAction codeStarConnectionsSourceAction
var buildAction codeBuildAction

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
	Triggers: []triggerProps{
		&triggerProps{
			ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
			GitConfiguration: &GitConfiguration{
				SourceAction: *SourceAction,
				PushFilter: []gitPushFilter{
					&gitPushFilter{
						TagsExcludes: []*string{
							jsii.String("exclude1"),
							jsii.String("exclude2"),
						},
						TagsIncludes: []*string{
							jsii.String("include*"),
						},
					},
				},
			},
		},
	},
})

type GitPullRequestEvent

type GitPullRequestEvent string

Event for trigger with pull request filter.

Example:

var sourceAction codeStarConnectionsSourceAction
var buildAction codeBuildAction

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
	Triggers: []triggerProps{
		&triggerProps{
			ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
			GitConfiguration: &GitConfiguration{
				SourceAction: *SourceAction,
				PullRequestFilter: []gitPullRequestFilter{
					&gitPullRequestFilter{
						BranchesExcludes: []*string{
							jsii.String("exclude1"),
							jsii.String("exclude2"),
						},
						BranchesIncludes: []*string{
							jsii.String("include1"),
							jsii.String("include2"),
						},
						Events: []gitPullRequestEvent{
							codepipeline.*gitPullRequestEvent_OPEN,
							codepipeline.*gitPullRequestEvent_CLOSED,
						},
					},
				},
			},
		},
	},
})

const (
	// OPEN.
	GitPullRequestEvent_OPEN GitPullRequestEvent = "OPEN"
	// UPDATED.
	GitPullRequestEvent_UPDATED GitPullRequestEvent = "UPDATED"
	// CLOSED.
	GitPullRequestEvent_CLOSED GitPullRequestEvent = "CLOSED"
)

type GitPullRequestFilter

type GitPullRequestFilter struct {
	// The list of patterns of Git branches that, when pull request events occurs, are to be excluded from starting the pipeline.
	//
	// You can filter with glob patterns. The `branchesExcludes` takes priority
	// over the `branchesIncludes`.
	//
	// Maximum length of this array is 8.
	// Default: - no branches.
	//
	BranchesExcludes *[]*string `field:"optional" json:"branchesExcludes" yaml:"branchesExcludes"`
	// The list of patterns of Git branches that, when pull request events occurs, are to be included as criteria that starts the pipeline.
	//
	// You can filter with glob patterns. The `branchesExcludes` takes priority
	// over the `branchesIncludes`.
	//
	// Maximum length of this array is 8.
	// Default: - no branches.
	//
	BranchesIncludes *[]*string `field:"optional" json:"branchesIncludes" yaml:"branchesIncludes"`
	// The field that specifies which pull request events to filter on (opened, updated, closed) for the trigger configuration.
	// Default: - all events.
	//
	Events *[]GitPullRequestEvent `field:"optional" json:"events" yaml:"events"`
	// The list of patterns of Git repository file paths that, when pull request events occurs, are to be excluded from starting the pipeline.
	//
	// You can filter with glob patterns. The `filePathsExcludes` takes priority
	// over the `filePathsIncludes`.
	//
	// Maximum length of this array is 8.
	// Default: - no filePaths.
	//
	FilePathsExcludes *[]*string `field:"optional" json:"filePathsExcludes" yaml:"filePathsExcludes"`
	// The list of patterns of Git repository file paths that, when pull request events occurs, are to be included as criteria that starts the pipeline.
	//
	// You can filter with glob patterns. The `filePathsExcludes` takes priority
	// over the `filePathsIncludes`.
	//
	// Maximum length of this array is 8.
	// Default: - no filePaths.
	//
	FilePathsIncludes *[]*string `field:"optional" json:"filePathsIncludes" yaml:"filePathsIncludes"`
}

Git pull request filter for trigger.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

gitPullRequestFilter := &GitPullRequestFilter{
	BranchesExcludes: []*string{
		jsii.String("branchesExcludes"),
	},
	BranchesIncludes: []*string{
		jsii.String("branchesIncludes"),
	},
	Events: []gitPullRequestEvent{
		awscdk.Aws_codepipeline.*gitPullRequestEvent_OPEN,
	},
	FilePathsExcludes: []*string{
		jsii.String("filePathsExcludes"),
	},
	FilePathsIncludes: []*string{
		jsii.String("filePathsIncludes"),
	},
}

type GitPushFilter

type GitPushFilter struct {
	// The list of patterns of Git tags that, when pushed, are to be excluded from starting the pipeline.
	//
	// You can filter with glob patterns. The `tagsExcludes` takes priority
	// over the `tagsIncludes`.
	//
	// Maximum length of this array is 8.
	// Default: - no tags.
	//
	TagsExcludes *[]*string `field:"optional" json:"tagsExcludes" yaml:"tagsExcludes"`
	// The list of patterns of Git tags that, when pushed, are to be included as criteria that starts the pipeline.
	//
	// You can filter with glob patterns. The `tagsExcludes` takes priority
	// over the `tagsIncludes`.
	//
	// Maximum length of this array is 8.
	// Default: - no tags.
	//
	TagsIncludes *[]*string `field:"optional" json:"tagsIncludes" yaml:"tagsIncludes"`
}

Git push filter for trigger.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

gitPushFilter := &GitPushFilter{
	TagsExcludes: []*string{
		jsii.String("tagsExcludes"),
	},
	TagsIncludes: []*string{
		jsii.String("tagsIncludes"),
	},
}

type GlobalVariables

type GlobalVariables interface {
}

The CodePipeline variables that are global, not bound to a specific action.

This class defines a bunch of static fields that represent the different variables. These can be used can be used in any action configuration.

Example:

// OtherAction is some action type that produces variables, like EcrSourceAction
// OtherAction is some action type that produces variables, like EcrSourceAction
NewOtherAction(&otherActionProps{
	// ...
	config: codepipeline.GlobalVariables_ExecutionId(),
	actionName: jsii.String("otherAction"),
})

func NewGlobalVariables

func NewGlobalVariables() GlobalVariables

type IAction

type IAction interface {
	// The callback invoked when this Action is added to a Pipeline.
	Bind(scope constructs.Construct, stage IStage, options *ActionBindOptions) *ActionConfig
	// Creates an Event that will be triggered whenever the state of this Action changes.
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	// The simple properties of the Action, like its Owner, name, etc.
	//
	// Note that this accessor will be called before the `bind` callback.
	ActionProperties() *ActionProperties
}

A Pipeline Action.

If you want to implement this interface, consider extending the `Action` class, which contains some common logic.

type IPipeline

type IPipeline interface {
	awscodestarnotifications.INotificationRuleSource
	awscdk.IResource
	// Defines a CodeStar notification rule triggered when the pipeline events emitted by you specified, it very similar to `onEvent` API.
	//
	// You can also use the methods `notifyOnExecutionStateChange`, `notifyOnAnyStageStateChange`,
	// `notifyOnAnyActionStateChange` and `notifyOnAnyManualApprovalStateChange`
	// to define rules for these specific event emitted.
	//
	// Returns: CodeStar notification rule associated with this build project.
	NotifyOn(id *string, target awscodestarnotifications.INotificationRuleTarget, options *PipelineNotifyOnOptions) awscodestarnotifications.INotificationRule
	// Define an notification rule triggered by the set of the "Action execution" events emitted from this pipeline.
	// See: https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
	//
	NotifyOnAnyActionStateChange(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Define an notification rule triggered by the set of the "Manual approval" events emitted from this pipeline.
	// See: https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
	//
	NotifyOnAnyManualApprovalStateChange(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Define an notification rule triggered by the set of the "Stage execution" events emitted from this pipeline.
	// See: https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
	//
	NotifyOnAnyStageStateChange(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Define an notification rule triggered by the set of the "Pipeline execution" events emitted from this pipeline.
	// See: https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline
	//
	NotifyOnExecutionStateChange(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Define an event rule triggered by this CodePipeline.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Define an event rule triggered by the "CodePipeline Pipeline Execution State Change" event emitted from this pipeline.
	OnStateChange(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// The ARN of the Pipeline.
	PipelineArn() *string
	// The name of the Pipeline.
	PipelineName() *string
}

The abstract view of an AWS CodePipeline as required and used by Actions.

It extends `events.IRuleTarget`, so this interface can be used as a Target for CloudWatch Events.

func Pipeline_FromPipelineArn

func Pipeline_FromPipelineArn(scope constructs.Construct, id *string, pipelineArn *string) IPipeline

Import a pipeline into this app.

type IStage

type IStage interface {
	AddAction(action IAction)
	OnStateChange(name *string, target awsevents.IRuleTarget, options *awsevents.RuleProps) awsevents.Rule
	// The actions belonging to this stage.
	Actions() *[]IAction
	Pipeline() IPipeline
	// The physical, human-readable name of this Pipeline Stage.
	StageName() *string
}

The abstract interface of a Pipeline Stage that is used by Actions.

type Pipeline

type Pipeline interface {
	awscdk.Resource
	IPipeline
	// Bucket used to store output artifacts.
	ArtifactBucket() awss3.IBucket
	// Returns all of the `CrossRegionSupportStack`s that were generated automatically when dealing with Actions that reside in a different region than the Pipeline itself.
	CrossRegionSupport() *map[string]*CrossRegionSupport
	// The environment this resource belongs to.
	//
	// For resources that are created and managed by the CDK
	// (generally, those created by creating new class instances like Role, Bucket, etc.),
	// this is always the same as the environment of the stack they belong to;
	// however, for imported resources
	// (those obtained from static methods like fromRoleArn, fromBucketName, etc.),
	// that might be different than the stack they were imported into.
	Env() *awscdk.ResourceEnvironment
	// The tree node.
	Node() constructs.Node
	// Returns a string-encoded token that resolves to the physical name that should be passed to the CloudFormation resource.
	//
	// This value will resolve to one of the following:
	// - a concrete value (e.g. `"my-awesome-bucket"`)
	// - `undefined`, when a name should be generated by CloudFormation
	// - a concrete name generated automatically during synthesis, in
	//   cross-environment scenarios.
	PhysicalName() *string
	// ARN of this pipeline.
	PipelineArn() *string
	// The name of the pipeline.
	PipelineName() *string
	// The version of the pipeline.
	PipelineVersion() *string
	// The IAM role AWS CodePipeline will use to perform actions or assume roles for actions with a more specific IAM role.
	Role() awsiam.IRole
	// The stack in which this resource is defined.
	Stack() awscdk.Stack
	// Get the number of Stages in this Pipeline.
	StageCount() *float64
	// Returns the stages that comprise the pipeline.
	//
	// **Note**: the returned array is a defensive copy,
	// so adding elements to it has no effect.
	// Instead, use the `addStage` method if you want to add more stages
	// to the pipeline.
	Stages() *[]IStage
	// Creates a new Stage, and adds it to this Pipeline.
	//
	// Returns: the newly created Stage.
	AddStage(props *StageOptions) IStage
	// Adds a statement to the pipeline role.
	AddToRolePolicy(statement awsiam.PolicyStatement)
	// Adds a new Trigger to this Pipeline.
	//
	// Returns: the newly created trigger.
	AddTrigger(props *TriggerProps) Trigger
	// Adds a new Variable to this Pipeline.
	//
	// Returns: the newly created variable.
	AddVariable(variable Variable) Variable
	// Apply the given removal policy to this resource.
	//
	// The Removal Policy controls what happens to this resource when it stops
	// being managed by CloudFormation, either because you've removed it from the
	// CDK application or because you've made a change that requires the resource
	// to be replaced.
	//
	// The resource can be deleted (`RemovalPolicy.DESTROY`), or left in your AWS
	// account for data recovery and cleanup later (`RemovalPolicy.RETAIN`).
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns a source configuration for notification rule.
	BindAsNotificationRuleSource(_scope constructs.Construct) *awscodestarnotifications.NotificationRuleSourceConfig
	GeneratePhysicalName() *string
	// Returns an environment-sensitive token that should be used for the resource's "ARN" attribute (e.g. `bucket.bucketArn`).
	//
	// Normally, this token will resolve to `arnAttr`, but if the resource is
	// referenced across environments, `arnComponents` will be used to synthesize
	// a concrete ARN with the resource's physical name. Make sure to reference
	// `this.physicalName` in `arnComponents`.
	GetResourceArnAttribute(arnAttr *string, arnComponents *awscdk.ArnComponents) *string
	// Returns an environment-sensitive token that should be used for the resource's "name" attribute (e.g. `bucket.bucketName`).
	//
	// Normally, this token will resolve to `nameAttr`, but if the resource is
	// referenced across environments, it will be resolved to `this.physicalName`,
	// which will be a concrete name.
	GetResourceNameAttribute(nameAttr *string) *string
	// Defines a CodeStar notification rule triggered when the pipeline events emitted by you specified, it very similar to `onEvent` API.
	//
	// You can also use the methods `notifyOnExecutionStateChange`, `notifyOnAnyStageStateChange`,
	// `notifyOnAnyActionStateChange` and `notifyOnAnyManualApprovalStateChange`
	// to define rules for these specific event emitted.
	NotifyOn(id *string, target awscodestarnotifications.INotificationRuleTarget, options *PipelineNotifyOnOptions) awscodestarnotifications.INotificationRule
	// Define an notification rule triggered by the set of the "Action execution" events emitted from this pipeline.
	NotifyOnAnyActionStateChange(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Define an notification rule triggered by the set of the "Manual approval" events emitted from this pipeline.
	NotifyOnAnyManualApprovalStateChange(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Define an notification rule triggered by the set of the "Stage execution" events emitted from this pipeline.
	NotifyOnAnyStageStateChange(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Define an notification rule triggered by the set of the "Pipeline execution" events emitted from this pipeline.
	NotifyOnExecutionStateChange(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Defines an event rule triggered by this CodePipeline.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines an event rule triggered by the "CodePipeline Pipeline Execution State Change" event emitted from this pipeline.
	OnStateChange(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Access one of the pipeline's stages by stage name.
	Stage(stageName *string) IStage
	// Returns a string representation of this construct.
	ToString() *string
}

An AWS CodePipeline pipeline with its associated IAM role and S3 bucket.

Example:

// create a pipeline
import codecommit "github.com/aws/aws-cdk-go/awscdk"

// add a source action to the stage
var repo repository
var sourceArtifact artifact

pipeline := codepipeline.NewPipeline(this, jsii.String("Pipeline"))

// add a stage
sourceStage := pipeline.AddStage(&StageOptions{
	StageName: jsii.String("Source"),
})
sourceStage.AddAction(codepipeline_actions.NewCodeCommitSourceAction(&CodeCommitSourceActionProps{
	ActionName: jsii.String("Source"),
	Output: sourceArtifact,
	Repository: repo,
}))

func NewPipeline

func NewPipeline(scope constructs.Construct, id *string, props *PipelineProps) Pipeline

type PipelineNotificationEvents

type PipelineNotificationEvents string

The list of event types for AWS Codepipeline Pipeline. See: https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#events-ref-pipeline

const (
	// Trigger notification when pipeline execution failed.
	PipelineNotificationEvents_PIPELINE_EXECUTION_FAILED PipelineNotificationEvents = "PIPELINE_EXECUTION_FAILED"
	// Trigger notification when pipeline execution canceled.
	PipelineNotificationEvents_PIPELINE_EXECUTION_CANCELED PipelineNotificationEvents = "PIPELINE_EXECUTION_CANCELED"
	// Trigger notification when pipeline execution started.
	PipelineNotificationEvents_PIPELINE_EXECUTION_STARTED PipelineNotificationEvents = "PIPELINE_EXECUTION_STARTED"
	// Trigger notification when pipeline execution resumed.
	PipelineNotificationEvents_PIPELINE_EXECUTION_RESUMED PipelineNotificationEvents = "PIPELINE_EXECUTION_RESUMED"
	// Trigger notification when pipeline execution succeeded.
	PipelineNotificationEvents_PIPELINE_EXECUTION_SUCCEEDED PipelineNotificationEvents = "PIPELINE_EXECUTION_SUCCEEDED"
	// Trigger notification when pipeline execution superseded.
	PipelineNotificationEvents_PIPELINE_EXECUTION_SUPERSEDED PipelineNotificationEvents = "PIPELINE_EXECUTION_SUPERSEDED"
	// Trigger notification when pipeline stage execution started.
	PipelineNotificationEvents_STAGE_EXECUTION_STARTED PipelineNotificationEvents = "STAGE_EXECUTION_STARTED"
	// Trigger notification when pipeline stage execution succeeded.
	PipelineNotificationEvents_STAGE_EXECUTION_SUCCEEDED PipelineNotificationEvents = "STAGE_EXECUTION_SUCCEEDED"
	// Trigger notification when pipeline stage execution resumed.
	PipelineNotificationEvents_STAGE_EXECUTION_RESUMED PipelineNotificationEvents = "STAGE_EXECUTION_RESUMED"
	// Trigger notification when pipeline stage execution canceled.
	PipelineNotificationEvents_STAGE_EXECUTION_CANCELED PipelineNotificationEvents = "STAGE_EXECUTION_CANCELED"
	// Trigger notification when pipeline stage execution failed.
	PipelineNotificationEvents_STAGE_EXECUTION_FAILED PipelineNotificationEvents = "STAGE_EXECUTION_FAILED"
	// Trigger notification when pipeline action execution succeeded.
	PipelineNotificationEvents_ACTION_EXECUTION_SUCCEEDED PipelineNotificationEvents = "ACTION_EXECUTION_SUCCEEDED"
	// Trigger notification when pipeline action execution failed.
	PipelineNotificationEvents_ACTION_EXECUTION_FAILED PipelineNotificationEvents = "ACTION_EXECUTION_FAILED"
	// Trigger notification when pipeline action execution canceled.
	PipelineNotificationEvents_ACTION_EXECUTION_CANCELED PipelineNotificationEvents = "ACTION_EXECUTION_CANCELED"
	// Trigger notification when pipeline action execution started.
	PipelineNotificationEvents_ACTION_EXECUTION_STARTED PipelineNotificationEvents = "ACTION_EXECUTION_STARTED"
	// Trigger notification when pipeline manual approval failed.
	PipelineNotificationEvents_MANUAL_APPROVAL_FAILED PipelineNotificationEvents = "MANUAL_APPROVAL_FAILED"
	// Trigger notification when pipeline manual approval needed.
	PipelineNotificationEvents_MANUAL_APPROVAL_NEEDED PipelineNotificationEvents = "MANUAL_APPROVAL_NEEDED"
	// Trigger notification when pipeline manual approval succeeded.
	PipelineNotificationEvents_MANUAL_APPROVAL_SUCCEEDED PipelineNotificationEvents = "MANUAL_APPROVAL_SUCCEEDED"
)

type PipelineNotifyOnOptions

type PipelineNotifyOnOptions struct {
	// The name or email alias of the person who created the notification rule.
	//
	// If not specified, it means that the creator's alias is not provided.
	// Default: - No alias provided.
	//
	CreatedBy *string `field:"optional" json:"createdBy" yaml:"createdBy"`
	// The level of detail to include in the notifications for this resource.
	//
	// BASIC will include only the contents of the event as it would appear in AWS CloudWatch.
	// FULL will include any supplemental information provided by AWS CodeStar Notifications and/or the service for the resource for which the notification is created.
	// Default: DetailType.FULL
	//
	DetailType awscodestarnotifications.DetailType `field:"optional" json:"detailType" yaml:"detailType"`
	// The status of the notification rule.
	//
	// If the enabled is set to DISABLED, notifications aren't sent for the notification rule.
	// Default: true.
	//
	Enabled *bool `field:"optional" json:"enabled" yaml:"enabled"`
	// The name for the notification rule.
	//
	// Notification rule names must be unique in your AWS account.
	// Default: - generated from the `id`.
	//
	NotificationRuleName *string `field:"optional" json:"notificationRuleName" yaml:"notificationRuleName"`
	// A list of event types associated with this notification rule for CodePipeline Pipeline.
	//
	// For a complete list of event types and IDs, see Notification concepts in the Developer Tools Console User Guide.
	// See: https://docs.aws.amazon.com/dtconsole/latest/userguide/concepts.html#concepts-api
	//
	Events *[]PipelineNotificationEvents `field:"required" json:"events" yaml:"events"`
}

Additional options to pass to the notification rule.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"

pipelineNotifyOnOptions := &PipelineNotifyOnOptions{
	Events: []pipelineNotificationEvents{
		awscdk.Aws_codepipeline.*pipelineNotificationEvents_PIPELINE_EXECUTION_FAILED,
	},

	// the properties below are optional
	CreatedBy: jsii.String("createdBy"),
	DetailType: awscdk.Aws_codestarnotifications.DetailType_BASIC,
	Enabled: jsii.Boolean(false),
	NotificationRuleName: jsii.String("notificationRuleName"),
}

type PipelineProps

type PipelineProps struct {
	// The S3 bucket used by this Pipeline to store artifacts.
	// Default: - A new S3 bucket will be created.
	//
	ArtifactBucket awss3.IBucket `field:"optional" json:"artifactBucket" yaml:"artifactBucket"`
	// Create KMS keys for cross-account deployments.
	//
	// This controls whether the pipeline is enabled for cross-account deployments.
	//
	// By default cross-account deployments are enabled, but this feature requires
	// that KMS Customer Master Keys are created which have a cost of $1/month.
	//
	// If you do not need cross-account deployments, you can set this to `false` to
	// not create those keys and save on that cost (the artifact bucket will be
	// encrypted with an AWS-managed key). However, cross-account deployments will
	// no longer be possible.
	// Default: false - false if the feature flag `CODEPIPELINE_CROSS_ACCOUNT_KEYS_DEFAULT_VALUE_TO_FALSE`
	// is true, true otherwise.
	//
	CrossAccountKeys *bool `field:"optional" json:"crossAccountKeys" yaml:"crossAccountKeys"`
	// A map of region to S3 bucket name used for cross-region CodePipeline.
	//
	// For every Action that you specify targeting a different region than the Pipeline itself,
	// if you don't provide an explicit Bucket for that region using this property,
	// the construct will automatically create a Stack containing an S3 Bucket in that region.
	// Default: - None.
	//
	CrossRegionReplicationBuckets *map[string]awss3.IBucket `field:"optional" json:"crossRegionReplicationBuckets" yaml:"crossRegionReplicationBuckets"`
	// Enable KMS key rotation for the generated KMS keys.
	//
	// By default KMS key rotation is disabled, but will add an additional $1/month
	// for each year the key exists when enabled.
	// Default: - false (key rotation is disabled).
	//
	EnableKeyRotation *bool `field:"optional" json:"enableKeyRotation" yaml:"enableKeyRotation"`
	// The method that the pipeline will use to handle multiple executions.
	// Default: - ExecutionMode.SUPERSEDED
	//
	ExecutionMode ExecutionMode `field:"optional" json:"executionMode" yaml:"executionMode"`
	// Name of the pipeline.
	// Default: - AWS CloudFormation generates an ID and uses that for the pipeline name.
	//
	PipelineName *string `field:"optional" json:"pipelineName" yaml:"pipelineName"`
	// Type of the pipeline.
	// See: https://docs.aws.amazon.com/codepipeline/latest/userguide/pipeline-types-planning.html
	//
	// Default: - PipelineType.V2 if the feature flag `CODEPIPELINE_DEFAULT_PIPELINE_TYPE_TO_V2`
	// is true, PipelineType.V1 otherwise
	//
	PipelineType PipelineType `field:"optional" json:"pipelineType" yaml:"pipelineType"`
	// Indicates whether to rerun the AWS CodePipeline pipeline after you update it.
	// Default: false.
	//
	RestartExecutionOnUpdate *bool `field:"optional" json:"restartExecutionOnUpdate" yaml:"restartExecutionOnUpdate"`
	// Reuse the same cross region support stack for all pipelines in the App.
	// Default: - true (Use the same support stack for all pipelines in App).
	//
	ReuseCrossRegionSupportStacks *bool `field:"optional" json:"reuseCrossRegionSupportStacks" yaml:"reuseCrossRegionSupportStacks"`
	// The IAM role to be assumed by this Pipeline.
	// Default: a new IAM role will be created.
	//
	Role awsiam.IRole `field:"optional" json:"role" yaml:"role"`
	// The list of Stages, in order, to create this Pipeline with.
	//
	// You can always add more Stages later by calling `Pipeline#addStage`.
	// Default: - None.
	//
	Stages *[]*StageProps `field:"optional" json:"stages" yaml:"stages"`
	// The trigger configuration specifying a type of event, such as Git tags, that starts the pipeline.
	//
	// When a trigger configuration is specified, default change detection for repository
	// and branch commits is disabled.
	//
	// `triggers` can only be used when `pipelineType` is set to `PipelineType.V2`.
	// You can always add more triggers later by calling `Pipeline#addTrigger`.
	// Default: - No triggers.
	//
	Triggers *[]*TriggerProps `field:"optional" json:"triggers" yaml:"triggers"`
	// A list that defines the pipeline variables for a pipeline resource.
	//
	// `variables` can only be used when `pipelineType` is set to `PipelineType.V2`.
	// You can always add more variables later by calling `Pipeline#addVariable`.
	// Default: - No variables.
	//
	Variables *[]Variable `field:"optional" json:"variables" yaml:"variables"`
}

Example:

var sourceAction s3SourceAction
var sourceOutput artifact
var deployBucket bucket

// Pipeline-level variable
variable := codepipeline.NewVariable(&VariableProps{
	VariableName: jsii.String("bucket-var"),
	Description: jsii.String("description"),
	DefaultValue: jsii.String("sample"),
})

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Variables: []variable{
		variable,
	},
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Deploy"),
			Actions: []*iAction{
				codepipeline_actions.NewS3DeployAction(&S3DeployActionProps{
					ActionName: jsii.String("DeployAction"),
					// can reference the variables
					ObjectKey: fmt.Sprintf("%v.txt", variable.Reference()),
					Input: sourceOutput,
					Bucket: deployBucket,
				}),
			},
		},
	},
})

type PipelineType

type PipelineType string

Pipeline types.

Example:

var sourceAction codeStarConnectionsSourceAction
var buildAction codeBuildAction

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
	Triggers: []triggerProps{
		&triggerProps{
			ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
			GitConfiguration: &GitConfiguration{
				SourceAction: *SourceAction,
				PushFilter: []gitPushFilter{
					&gitPushFilter{
						TagsExcludes: []*string{
							jsii.String("exclude1"),
							jsii.String("exclude2"),
						},
						TagsIncludes: []*string{
							jsii.String("include*"),
						},
					},
				},
			},
		},
	},
})

const (
	// V1 type.
	PipelineType_V1 PipelineType = "V1"
	// V2 type.
	PipelineType_V2 PipelineType = "V2"
)

type ProviderType

type ProviderType string

Provider type for trigger.

Example:

var sourceAction codeStarConnectionsSourceAction
var buildAction codeBuildAction

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
	Triggers: []triggerProps{
		&triggerProps{
			ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
			GitConfiguration: &GitConfiguration{
				SourceAction: *SourceAction,
				PushFilter: []gitPushFilter{
					&gitPushFilter{
						TagsExcludes: []*string{
							jsii.String("exclude1"),
							jsii.String("exclude2"),
						},
						TagsIncludes: []*string{
							jsii.String("include*"),
						},
					},
				},
			},
		},
	},
})

const (
	// CodeStarSourceConnection.
	ProviderType_CODE_STAR_SOURCE_CONNECTION ProviderType = "CODE_STAR_SOURCE_CONNECTION"
)

type StageOptions

type StageOptions struct {
	// The physical, human-readable name to assign to this Pipeline Stage.
	StageName *string `field:"required" json:"stageName" yaml:"stageName"`
	// The list of Actions to create this Stage with.
	//
	// You can always add more Actions later by calling `IStage#addAction`.
	Actions *[]IAction `field:"optional" json:"actions" yaml:"actions"`
	// The reason for disabling transition to this stage.
	//
	// Only applicable
	// if `transitionToEnabled` is set to `false`.
	// Default: 'Transition disabled'.
	//
	TransitionDisabledReason *string `field:"optional" json:"transitionDisabledReason" yaml:"transitionDisabledReason"`
	// Whether to enable transition to this stage.
	// Default: true.
	//
	TransitionToEnabled *bool           `field:"optional" json:"transitionToEnabled" yaml:"transitionToEnabled"`
	Placement           *StagePlacement `field:"optional" json:"placement" yaml:"placement"`
}

Example:

import "github.com/aws/aws-cdk-go/awscdk"

pipeline := codepipeline.NewPipeline(this, jsii.String("MyPipeline"))
startState := stepfunctions.NewPass(this, jsii.String("StartState"))
simpleStateMachine := stepfunctions.NewStateMachine(this, jsii.String("SimpleStateMachine"), &StateMachineProps{
	Definition: startState,
})
stepFunctionAction := codepipeline_actions.NewStepFunctionInvokeAction(&StepFunctionsInvokeActionProps{
	ActionName: jsii.String("Invoke"),
	StateMachine: simpleStateMachine,
	StateMachineInput: codepipeline_actions.StateMachineInput_Literal(map[string]*bool{
		"IsHelloWorldExample": jsii.Boolean(true),
	}),
})
pipeline.AddStage(&StageOptions{
	StageName: jsii.String("StepFunctions"),
	Actions: []iAction{
		stepFunctionAction,
	},
})

type StagePlacement

type StagePlacement struct {
	// Inserts the new Stage as a child of the given Stage (changing its current child Stage, if it had one).
	JustAfter IStage `field:"optional" json:"justAfter" yaml:"justAfter"`
	// Inserts the new Stage as a parent of the given Stage (changing its current parent Stage, if it had one).
	RightBefore IStage `field:"optional" json:"rightBefore" yaml:"rightBefore"`
}

Allows you to control where to place a new Stage when it's added to the Pipeline.

Note that you can provide only one of the below properties - specifying more than one will result in a validation error.

Example:

// Insert a new Stage at an arbitrary point
var pipeline pipeline
var anotherStage iStage
var yetAnotherStage iStage

someStage := pipeline.AddStage(&StageOptions{
	StageName: jsii.String("SomeStage"),
	Placement: &StagePlacement{
		// note: you can only specify one of the below properties
		RightBefore: anotherStage,
		JustAfter: yetAnotherStage,
	},
})

See: #justAfter.

type StageProps

type StageProps struct {
	// The physical, human-readable name to assign to this Pipeline Stage.
	StageName *string `field:"required" json:"stageName" yaml:"stageName"`
	// The list of Actions to create this Stage with.
	//
	// You can always add more Actions later by calling `IStage#addAction`.
	Actions *[]IAction `field:"optional" json:"actions" yaml:"actions"`
	// The reason for disabling transition to this stage.
	//
	// Only applicable
	// if `transitionToEnabled` is set to `false`.
	// Default: 'Transition disabled'.
	//
	TransitionDisabledReason *string `field:"optional" json:"transitionDisabledReason" yaml:"transitionDisabledReason"`
	// Whether to enable transition to this stage.
	// Default: true.
	//
	TransitionToEnabled *bool `field:"optional" json:"transitionToEnabled" yaml:"transitionToEnabled"`
}

Construction properties of a Pipeline Stage.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var action action

stageProps := &StageProps{
	StageName: jsii.String("stageName"),

	// the properties below are optional
	Actions: []iAction{
		action,
	},
	TransitionDisabledReason: jsii.String("transitionDisabledReason"),
	TransitionToEnabled: jsii.Boolean(false),
}

type Trigger

type Trigger interface {
	// The pipeline source action where the trigger configuration.
	SourceAction() IAction
}

Trigger.

Example:

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import "github.com/aws/aws-cdk-go/awscdk"

var action action

trigger := awscdk.Aws_codepipeline.NewTrigger(&TriggerProps{
	ProviderType: awscdk.*Aws_codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,

	// the properties below are optional
	GitConfiguration: &GitConfiguration{
		SourceAction: action,

		// the properties below are optional
		PullRequestFilter: []gitPullRequestFilter{
			&gitPullRequestFilter{
				BranchesExcludes: []*string{
					jsii.String("branchesExcludes"),
				},
				BranchesIncludes: []*string{
					jsii.String("branchesIncludes"),
				},
				Events: []gitPullRequestEvent{
					awscdk.*Aws_codepipeline.*gitPullRequestEvent_OPEN,
				},
				FilePathsExcludes: []*string{
					jsii.String("filePathsExcludes"),
				},
				FilePathsIncludes: []*string{
					jsii.String("filePathsIncludes"),
				},
			},
		},
		PushFilter: []gitPushFilter{
			&gitPushFilter{
				TagsExcludes: []*string{
					jsii.String("tagsExcludes"),
				},
				TagsIncludes: []*string{
					jsii.String("tagsIncludes"),
				},
			},
		},
	},
})

func NewTrigger

func NewTrigger(props *TriggerProps) Trigger

type TriggerProps

type TriggerProps struct {
	// The source provider for the event, such as connections configured for a repository with Git tags, for the specified trigger configuration.
	ProviderType ProviderType `field:"required" json:"providerType" yaml:"providerType"`
	// Provides the filter criteria and the source stage for the repository event that starts the pipeline, such as Git tags.
	// Default: - no configuration.
	//
	GitConfiguration *GitConfiguration `field:"optional" json:"gitConfiguration" yaml:"gitConfiguration"`
}

Properties of trigger.

Example:

var pipeline pipeline
var sourceAction codeStarConnectionsSourceAction

pipeline.AddTrigger(&TriggerProps{
	ProviderType: codepipeline.ProviderType_CODE_STAR_SOURCE_CONNECTION,
	GitConfiguration: &GitConfiguration{
		SourceAction: *SourceAction,
		PushFilter: []gitPushFilter{
			&gitPushFilter{
				TagsExcludes: []*string{
					jsii.String("exclude1"),
					jsii.String("exclude2"),
				},
				TagsIncludes: []*string{
					jsii.String("include*"),
				},
			},
		},
	},
})

type Variable

type Variable interface {
	// The name of a pipeline-level variable.
	VariableName() *string
	// Reference the variable name at Pipeline actions.
	//
	// Returns: The variable name in a format that can be referenced at Pipeline actions.
	Reference() *string
}

Pipeline-Level variable.

Example:

var sourceAction s3SourceAction
var sourceOutput artifact
var deployBucket bucket

// Pipeline-level variable
variable := codepipeline.NewVariable(&VariableProps{
	VariableName: jsii.String("bucket-var"),
	Description: jsii.String("description"),
	DefaultValue: jsii.String("sample"),
})

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Variables: []variable{
		variable,
	},
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Deploy"),
			Actions: []*iAction{
				codepipeline_actions.NewS3DeployAction(&S3DeployActionProps{
					ActionName: jsii.String("DeployAction"),
					// can reference the variables
					ObjectKey: fmt.Sprintf("%v.txt", variable.Reference()),
					Input: sourceOutput,
					Bucket: deployBucket,
				}),
			},
		},
	},
})

func NewVariable

func NewVariable(props *VariableProps) Variable

type VariableProps

type VariableProps struct {
	// The name of a pipeline-level variable.
	VariableName *string `field:"required" json:"variableName" yaml:"variableName"`
	// The default value of a pipeline-level variable.
	// Default: - No default value.
	//
	DefaultValue *string `field:"optional" json:"defaultValue" yaml:"defaultValue"`
	// The description of a pipeline-level variable.
	//
	// It's used to add additional context
	// about the variable, and not being used at time when pipeline executes.
	// Default: - No description.
	//
	Description *string `field:"optional" json:"description" yaml:"description"`
}

Properties of pipeline-level variable.

Example:

var sourceAction s3SourceAction
var sourceOutput artifact
var deployBucket bucket

// Pipeline-level variable
variable := codepipeline.NewVariable(&VariableProps{
	VariableName: jsii.String("bucket-var"),
	Description: jsii.String("description"),
	DefaultValue: jsii.String("sample"),
})

codepipeline.NewPipeline(this, jsii.String("Pipeline"), &PipelineProps{
	PipelineType: codepipeline.PipelineType_V2,
	Variables: []variable{
		variable,
	},
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Deploy"),
			Actions: []*iAction{
				codepipeline_actions.NewS3DeployAction(&S3DeployActionProps{
					ActionName: jsii.String("DeployAction"),
					// can reference the variables
					ObjectKey: fmt.Sprintf("%v.txt", variable.Reference()),
					Input: sourceOutput,
					Bucket: deployBucket,
				}),
			},
		},
	},
})