awscodepipeline

package
v2.131.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 1, 2024 License: Apache-2.0 Imports: 11 Imported by: 7

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, specify the triggers property. When a Git tag is pushed, your pipeline starts. You can filter with glob patterns. The tagsExcludes takes priority over the tagsIncludes.

The triggers can only be used with pipeline type V2.

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*"),
						},
					},
				},
			},
		},
	},
})

Or 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*"),
				},
			},
		},
	},
})

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.

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

Constants

This section is empty.

Variables

This section is empty.

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 added in v2.128.0 

func NewTrigger_Override(t Trigger, props *TriggerProps)

func NewVariable_Override added in v2.128.0 

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 added in v2.32.0 

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{})
	AttrId() *string
	// 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),
				},
			},
			Name: jsii.String("name"),

			// the properties below are optional
			Blockers: []interface{}{
				&BlockerDeclarationProperty{
					Name: jsii.String("name"),
					Type: jsii.String("type"),
				},
			},
		},
	},

	// 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
	//
	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),
				},
			},
			Name: jsii.String("name"),

			// the properties below are optional
			Blockers: []interface{}{
				&BlockerDeclarationProperty{
					Name: jsii.String("name"),
					Type: jsii.String("type"),
				},
			},
		},
	},

	// 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"`
}

Represents information about an action declaration.

> Documentation for the `timeoutInMinutes` parameter in the `ActionDeclaration` is not yet available for CloudFormation and CDK resources in CodePipeline. For more information about the configurable timeout for manual approval actions, see the [ActionDeclaration](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ActionDeclaration.html) in the CodePipeline API Reference.

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),
}

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_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_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_GitBranchFilterCriteriaProperty added in v2.129.0 

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 added in v2.116.0 

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 added in v2.129.0 

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 added in v2.129.0 

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 added in v2.116.0 

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 added in v2.116.0 

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 added in v2.116.0 

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_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"`
	// 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"`
}

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),
		},
	},
	Name: jsii.String("name"),

	// the properties below are optional
	Blockers: []interface{}{
		&BlockerDeclarationProperty{
			Name: jsii.String("name"),
			Type: jsii.String("type"),
		},
	},
}

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_VariableDeclarationProperty added in v2.116.0 

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.
	//
	// - 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.
	// 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 GitConfiguration added in v2.128.0 

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, 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 GitPushFilter added in v2.128.0 

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 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
	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"`
	// 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.V1
	//
	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 project pipelineProject

repository := codecommit.NewRepository(this, jsii.String("MyRepository"), &RepositoryProps{
	RepositoryName: jsii.String("MyRepository"),
})
project := codebuild.NewPipelineProject(this, jsii.String("MyProject"))

sourceOutput := codepipeline.NewArtifact()
sourceAction := codepipeline_actions.NewCodeCommitSourceAction(&CodeCommitSourceActionProps{
	ActionName: jsii.String("CodeCommit"),
	Repository: Repository,
	Output: sourceOutput,
})
buildAction := codepipeline_actions.NewCodeBuildAction(&CodeBuildActionProps{
	ActionName: jsii.String("CodeBuild"),
	Project: Project,
	Input: sourceOutput,
	Outputs: []artifact{
		codepipeline.NewArtifact(),
	},
	 // optional
	ExecuteBatchBuild: jsii.Boolean(true),
	 // optional, defaults to false
	CombineBatchBuildArtifacts: jsii.Boolean(true),
})

codepipeline.NewPipeline(this, jsii.String("MyPipeline"), &PipelineProps{
	Stages: []stageProps{
		&stageProps{
			StageName: jsii.String("Source"),
			Actions: []iAction{
				sourceAction,
			},
		},
		&stageProps{
			StageName: jsii.String("Build"),
			Actions: []*iAction{
				buildAction,
			},
		},
	},
})

type PipelineType added in v2.128.0 

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 added in v2.128.0 

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 added in v2.128.0 

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
		PushFilter: []gitPushFilter{
			&gitPushFilter{
				TagsExcludes: []*string{
					jsii.String("tagsExcludes"),
				},
				TagsIncludes: []*string{
					jsii.String("tagsIncludes"),
				},
			},
		},
	},
})

func NewTrigger added in v2.128.0 

func NewTrigger(props *TriggerProps) Trigger

type TriggerProps added in v2.128.0 

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 added in v2.128.0 

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 added in v2.128.0 

func NewVariable(props *VariableProps) Variable

type VariableProps added in v2.128.0 

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,
				}),
			},
		},
	},
})

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.