awscodebuild

package
v1.168.0-devpreview Latest Latest
Warning

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

 Go to latest Published: Aug 9, 2022 License: Apache-2.0 Imports: 18 Imported by: 5

README

AWS CodeBuild Construct Library

AWS CodeBuild is a fully managed continuous integration service that compiles source code, runs tests, and produces software packages that are ready to deploy. With CodeBuild, you don’t need to provision, manage, and scale your own build servers. CodeBuild scales continuously and processes multiple builds concurrently, so your builds are not left waiting in a queue. You can get started quickly by using prepackaged build environments, or you can create custom build environments that use your own build tools. With CodeBuild, you are charged by the minute for the compute resources you use.

Installation

Install the module:

$ npm i @aws-cdk/aws-codebuild

Import it into your code:

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

The codebuild.Project construct represents a build project resource. See the reference documentation for a comprehensive list of initialization properties, methods and attributes.

Source

Build projects are usually associated with a source, which is specified via the source property which accepts a class that extends the Source abstract base class. The default is to have no source associated with the build project; the buildSpec option is required in that case.

Here's a CodeBuild project with no source which simply prints Hello, CodeBuild!:

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("echo \"Hello, CodeBuild!\""),
				},
			},
		},
	}),
})
CodeCommitSource

Use an AWS CodeCommit repository as the source of this build:

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


repository := codecommit.NewRepository(this, jsii.String("MyRepo"), &repositoryProps{
	repositoryName: jsii.String("foo"),
})
codebuild.NewProject(this, jsii.String("MyFirstCodeCommitProject"), &projectProps{
	source: codebuild.source.codeCommit(&codeCommitSourceProps{
		repository: repository,
	}),
})
S3Source

Create a CodeBuild project with an S3 bucket as the source:

bucket := s3.NewBucket(this, jsii.String("MyBucket"))

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	source: codebuild.source.s3(&s3SourceProps{
		bucket: bucket,
		path: jsii.String("path/to/file.zip"),
	}),
})

The CodeBuild role will be granted to read just the given path from the given bucket.

GitHubSource and GitHubEnterpriseSource

These source types can be used to build code from a GitHub repository. Example:

gitHubSource := codebuild.source.gitHub(&gitHubSourceProps{
	owner: jsii.String("awslabs"),
	repo: jsii.String("aws-cdk"),
	webhook: jsii.Boolean(true),
	 // optional, default: true if `webhookFilters` were provided, false otherwise
	webhookTriggersBatchBuild: jsii.Boolean(true),
	 // optional, default is false
	webhookFilters: []filterGroup{
		codebuild.*filterGroup.inEventOf(codebuild.eventAction_PUSH).andBranchIs(jsii.String("master")).andCommitMessageIs(jsii.String("the commit message")),
	},
})

To provide GitHub credentials, please either go to AWS CodeBuild Console to connect or call ImportSourceCredentials to persist your personal access token. Example:

aws codebuild import-source-credentials --server-type GITHUB --auth-type PERSONAL_ACCESS_TOKEN --token <token_value>
BitBucketSource

This source type can be used to build code from a BitBucket repository.

bbSource := codebuild.source.bitBucket(&bitBucketSourceProps{
	owner: jsii.String("owner"),
	repo: jsii.String("repo"),
})
For all Git sources

For all Git sources, you can fetch submodules while cloing git repo.

gitHubSource := codebuild.source.gitHub(&gitHubSourceProps{
	owner: jsii.String("awslabs"),
	repo: jsii.String("aws-cdk"),
	fetchSubmodules: jsii.Boolean(true),
})

Artifacts

CodeBuild Projects can produce Artifacts and upload them to S3. For example:

var bucket bucket


project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),
	artifacts: codebuild.artifacts.s3(&s3ArtifactsProps{
		bucket: bucket,
		includeBuildId: jsii.Boolean(false),
		packageZip: jsii.Boolean(true),
		path: jsii.String("another/path"),
		identifier: jsii.String("AddArtifact1"),
	}),
})

If you'd prefer your buildspec to be rendered as YAML in the template, use the fromObjectToYaml() method instead of fromObject().

Because we've not set the name property, this example will set the overrideArtifactName parameter, and produce an artifact named as defined in the Buildspec file, uploaded to an S3 bucket (bucket). The path will be another/path and the artifact will be a zipfile.

CodePipeline

To add a CodeBuild Project as an Action to CodePipeline, use the PipelineProject class instead of Project. It's a simple class that doesn't allow you to specify sources, secondarySources, artifacts or secondaryArtifacts, as these are handled by setting input and output CodePipeline Artifact instances on the Action, instead of setting them on the Project.

project := codebuild.NewPipelineProject(this, jsii.String("Project"), &pipelineProjectProps{
})

For more details, see the readme of the @aws-cdk/@aws-codepipeline-actions package.

Caching

You can save time when your project builds by using a cache. A cache can store reusable pieces of your build environment and use them across multiple builds. Your build project can use one of two types of caching: Amazon S3 or local. In general, S3 caching is a good option for small and intermediate build artifacts that are more expensive to build than to download. Local caching is a good option for large intermediate build artifacts because the cache is immediately available on the build host.

S3 Caching

With S3 caching, the cache is stored in an S3 bucket which is available regardless from what CodeBuild instance gets selected to run your CodeBuild job on. When using S3 caching, you must also add in a cache section to your buildspec which indicates the files to be cached:

var myCachingBucket bucket


codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	source: codebuild.source.bitBucket(&bitBucketSourceProps{
		owner: jsii.String("awslabs"),
		repo: jsii.String("aws-cdk"),
	}),

	cache: codebuild.cache.bucket(myCachingBucket),

	// BuildSpec with a 'cache' section necessary for S3 caching. This can
	// also come from 'buildspec.yml' in your source.
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("..."),
				},
			},
		},
		"cache": map[string][]*string{
			"paths": []*string{
				jsii.String("/root/cachedir/**/*"),
			},
		},
	}),
})

Note that two different CodeBuild Projects using the same S3 bucket will not share their cache: each Project will get a unique file in the S3 bucket to store the cache in.

Local Caching

With local caching, the cache is stored on the codebuild instance itself. This is simple, cheap and fast, but CodeBuild cannot guarantee a reuse of instance and hence cannot guarantee cache hits. For example, when a build starts and caches files locally, if two subsequent builds start at the same time afterwards only one of those builds would get the cache. Three different cache modes are supported, which can be turned on individually.

  • LocalCacheMode.SOURCE caches Git metadata for primary and secondary sources.
  • LocalCacheMode.DOCKER_LAYER caches existing Docker layers.
  • LocalCacheMode.CUSTOM caches directories you specify in the buildspec file.
codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	source: codebuild.source.gitHubEnterprise(&gitHubEnterpriseSourceProps{
		httpsCloneUrl: jsii.String("https://my-github-enterprise.com/owner/repo"),
	}),

	// Enable Docker AND custom caching
	cache: codebuild.cache.local(codebuild.localCacheMode_DOCKER_LAYER, codebuild.*localCacheMode_CUSTOM),

	// BuildSpec with a 'cache' section necessary for 'CUSTOM' caching. This can
	// also come from 'buildspec.yml' in your source.
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("..."),
				},
			},
		},
		"cache": map[string][]*string{
			"paths": []*string{
				jsii.String("/root/cachedir/**/*"),
			},
		},
	}),
})

Environment

By default, projects use a small instance with an Ubuntu 18.04 image. You can use the environment property to customize the build environment:

  • buildImage defines the Docker image used. See Images below for details on how to define build images.
  • certificate defines the location of a PEM encoded certificate to import.
  • computeType defines the instance type used for the build.
  • privileged can be set to true to allow privileged access.
  • environmentVariables can be set at this level (and also at the project level).

Images

The CodeBuild library supports both Linux and Windows images via the LinuxBuildImage (or LinuxArmBuildImage), and WindowsBuildImage classes, respectively.

You can specify one of the predefined Windows/Linux images by using one of the constants such as WindowsBuildImage.WIN_SERVER_CORE_2019_BASE, WindowsBuildImage.WINDOWS_BASE_2_0, LinuxBuildImage.STANDARD_2_0, or LinuxArmBuildImage.AMAZON_LINUX_2_ARM.

Alternatively, you can specify a custom image using one of the static methods on LinuxBuildImage:

  • LinuxBuildImage.fromDockerRegistry(image[, { secretsManagerCredentials }]) to reference an image in any public or private Docker registry.
  • LinuxBuildImage.fromEcrRepository(repo[, tag]) to reference an image available in an ECR repository.
  • LinuxBuildImage.fromAsset(parent, id, props) to use an image created from a local asset.
  • LinuxBuildImage.fromCodeBuildImageId(id) to reference a pre-defined, CodeBuild-provided Docker image.

or one of the corresponding methods on WindowsBuildImage:

  • WindowsBuildImage.fromDockerRegistry(image[, { secretsManagerCredentials }, imageType])
  • WindowsBuildImage.fromEcrRepository(repo[, tag, imageType])
  • WindowsBuildImage.fromAsset(parent, id, props, [, imageType])

or one of the corresponding methods on LinuxArmBuildImage:

  • LinuxArmBuildImage.fromEcrRepository(repo[, tag])

Note that the WindowsBuildImage version of the static methods accepts an optional parameter of type WindowsImageType, which can be either WindowsImageType.STANDARD, the default, or WindowsImageType.SERVER_2019:

var ecrRepository repository


codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	environment: &buildEnvironment{
		buildImage: codebuild.windowsBuildImage.fromEcrRepository(ecrRepository, jsii.String("v1.0"), codebuild.windowsImageType_SERVER_2019),
		// optional certificate to include in the build image
		certificate: &buildEnvironmentCertificate{
			bucket: s3.bucket.fromBucketName(this, jsii.String("Bucket"), jsii.String("my-bucket")),
			objectKey: jsii.String("path/to/cert.pem"),
		},
	},
})

The following example shows how to define an image from a Docker asset:

environment: &buildEnvironment{
	buildImage: codebuild.linuxBuildImage.fromAsset(this, jsii.String("MyImage"), &dockerImageAssetProps{
		directory: path.join(__dirname, jsii.String("demo-image")),
	}),
},

The following example shows how to define an image from an ECR repository:

environment: &buildEnvironment{
	buildImage: codebuild.linuxBuildImage.fromEcrRepository(ecrRepository, jsii.String("v1.0")),
},

The following example shows how to define an image from a private docker registry:

environment: &buildEnvironment{
	buildImage: codebuild.linuxBuildImage.fromDockerRegistry(jsii.String("my-registry/my-repo"), &dockerImageOptions{
		secretsManagerCredentials: secrets,
	}),
},
GPU images

The class LinuxGpuBuildImage contains constants for working with AWS Deep Learning Container images:

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	environment: &buildEnvironment{
		buildImage: codebuild.linuxGpuBuildImage_DLC_TENSORFLOW_2_1_0_INFERENCE(),
	},
})

One complication is that the repositories for the DLC images are in different accounts in different AWS regions. In most cases, the CDK will handle providing the correct account for you; in rare cases (for example, deploying to new regions) where our information might be out of date, you can always specify the account (along with the repository name and tag) explicitly using the awsDeepLearningContainersImage method:

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	environment: &buildEnvironment{
		buildImage: codebuild.linuxGpuBuildImage.awsDeepLearningContainersImage(jsii.String("tensorflow-inference"), jsii.String("2.1.0-gpu-py36-cu101-ubuntu18.04"), jsii.String("123456789012")),
	},
})

Alternatively, you can reference an image available in an ECR repository using the LinuxGpuBuildImage.fromEcrRepository(repo[, tag]) method.

Logs

CodeBuild lets you specify an S3 Bucket, CloudWatch Log Group or both to receive logs from your projects.

By default, logs will go to cloudwatch.

CloudWatch Logs Example
codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	logging: &loggingOptions{
		cloudWatch: &cloudWatchLoggingOptions{
			logGroup: logs.NewLogGroup(this, jsii.String("MyLogGroup")),
		},
	},
})
S3 Logs Example
codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	logging: &loggingOptions{
		s3: &s3LoggingOptions{
			bucket: s3.NewBucket(this, jsii.String("LogBucket")),
		},
	},
})

Credentials

CodeBuild allows you to store credentials used when communicating with various sources, like GitHub:

codebuild.NewGitHubSourceCredentials(this, jsii.String("CodeBuildGitHubCreds"), &gitHubSourceCredentialsProps{
	accessToken: awscdk.SecretValue.secretsManager(jsii.String("my-token")),
})

and BitBucket:

codebuild.NewBitBucketSourceCredentials(this, jsii.String("CodeBuildBitBucketCreds"), &bitBucketSourceCredentialsProps{
	username: awscdk.SecretValue.secretsManager(jsii.String("my-bitbucket-creds"), &secretsManagerSecretOptions{
		jsonField: jsii.String("username"),
	}),
	password: awscdk.SecretValue.secretsManager(jsii.String("my-bitbucket-creds"), &secretsManagerSecretOptions{
		jsonField: jsii.String("password"),
	}),
})

Note: the credentials are global to a given account in a given region - they are not defined per CodeBuild project. CodeBuild only allows storing a single credential of a given type (GitHub, GitHub Enterprise or BitBucket) in a given account in a given region - any attempt to save more than one will result in an error. You can use the list-source-credentials AWS CLI operation to inspect what credentials are stored in your account.

Test reports

You can specify a test report in your buildspec:

project := codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		// ...
		"reports": map[string]map[string]*string{
			"myReport": map[string]*string{
				"files": jsii.String("**/*"),
				"base-directory": jsii.String("build/test-results"),
			},
		},
	}),
})

This will create a new test report group, with the name <ProjectName>-myReport.

The project's role in the CDK will always be granted permissions to create and use report groups with names starting with the project's name; if you'd rather not have those permissions added, you can opt out of it when creating the project:

var source source


project := codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	source: source,
	grantReportGroupPermissions: jsii.Boolean(false),
})

Alternatively, you can specify an ARN of an existing resource group, instead of a simple name, in your buildspec:

var source source


// create a new ReportGroup
reportGroup := codebuild.NewReportGroup(this, jsii.String("ReportGroup"))

project := codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	source: source,
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		// ...
		"reports": map[string]map[string]*string{
			reportGroup.reportGroupArn: map[string]*string{
				"files": jsii.String("**/*"),
				"base-directory": jsii.String("build/test-results"),
			},
		},
	}),
})

If you do that, you need to grant the project's role permissions to write reports to that report group:

var project project
var reportGroup reportGroup


reportGroup.grantWrite(project)

For more information on the test reports feature, see the AWS CodeBuild documentation.

Events

CodeBuild projects can be used either as a source for events or be triggered by events via an event rule.

Using Project as an event target

The @aws-cdk/aws-events-targets.CodeBuildProject allows using an AWS CodeBuild project as a AWS CloudWatch event rule target:

// start build when a commit is pushed
import codecommit "github.com/aws/aws-cdk-go/awscdk"
import targets "github.com/aws/aws-cdk-go/awscdk"

var codeCommitRepository repository
var project project


codeCommitRepository.onCommit(jsii.String("OnCommit"), &onCommitOptions{
	target: targets.NewCodeBuildProject(project),
})
Using Project as an event source

To define Amazon CloudWatch event rules for build projects, use one of the onXxx methods:

import targets "github.com/aws/aws-cdk-go/awscdk"
var fn function
var project project


rule := project.onStateChange(jsii.String("BuildStateChange"), &onEventOptions{
	target: targets.NewLambdaFunction(fn),
})

CodeStar Notifications

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

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

var project project


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 := project.notifyOnBuildSucceeded(jsii.String("NotifyOnBuildSucceeded"), target)

Secondary sources and artifacts

CodeBuild Projects can get their sources from multiple places, and produce multiple outputs. For example:

import codecommit "github.com/aws/aws-cdk-go/awscdk"
var repo repository
var bucket bucket


project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	secondarySources: []iSource{
		codebuild.source.codeCommit(&codeCommitSourceProps{
			identifier: jsii.String("source2"),
			repository: repo,
		}),
	},
	secondaryArtifacts: []iArtifacts{
		codebuild.artifacts.s3(&s3ArtifactsProps{
			identifier: jsii.String("artifact2"),
			bucket: bucket,
			path: jsii.String("some/path"),
			name: jsii.String("file.zip"),
		}),
	},
})

Note that the identifier property is required for both secondary sources and artifacts.

The contents of the secondary source is available to the build under the directory specified by the CODEBUILD_SRC_DIR_<identifier> environment variable (so, CODEBUILD_SRC_DIR_source2 in the above case).

The secondary artifacts have their own section in the buildspec, under the regular artifacts one. Each secondary artifact has its own section, beginning with their identifier.

So, a buildspec for the above Project could look something like this:

project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	// secondary sources and artifacts as above...
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("cd $CODEBUILD_SRC_DIR_source2"),
					jsii.String("touch output2.txt"),
				},
			},
		},
		"artifacts": map[string]map[string]map[string]interface{}{
			"secondary-artifacts": map[string]map[string]interface{}{
				"artifact2": map[string]interface{}{
					"base-directory": jsii.String("$CODEBUILD_SRC_DIR_source2"),
					"files": []*string{
						jsii.String("output2.txt"),
					},
				},
			},
		},
	}),
})
Definition of VPC configuration in CodeBuild Project

Typically, resources in an VPC are not accessible by AWS CodeBuild. To enable access, you must provide additional VPC-specific configuration information as part of your CodeBuild project configuration. This includes the VPC ID, the VPC subnet IDs, and the VPC security group IDs. VPC-enabled builds are then able to access resources inside your VPC.

For further Information see https://docs.aws.amazon.com/codebuild/latest/userguide/vpc-support.html

Use Cases VPC connectivity from AWS CodeBuild builds makes it possible to:

  • Run integration tests from your build against data in an Amazon RDS database that's isolated on a private subnet.
  • Query data in an Amazon ElastiCache cluster directly from tests.
  • Interact with internal web services hosted on Amazon EC2, Amazon ECS, or services that use internal Elastic Load Balancing.
  • Retrieve dependencies from self-hosted, internal artifact repositories, such as PyPI for Python, Maven for Java, and npm for Node.js.
  • Access objects in an Amazon S3 bucket configured to allow access through an Amazon VPC endpoint only.
  • Query external web services that require fixed IP addresses through the Elastic IP address of the NAT gateway or NAT instance associated with your subnet(s).

Your builds can access any resource that's hosted in your VPC.

Enable Amazon VPC Access in your CodeBuild Projects

Pass the VPC when defining your Project, then make sure to give the CodeBuild's security group the right permissions to access the resources that it needs by using the connections object.

For example:

var loadBalancer applicationLoadBalancer


vpc := ec2.NewVpc(this, jsii.String("MyVPC"))
project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	vpc: vpc,
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
	}),
})

project.connections.allowTo(loadBalancer, ec2.port.tcp(jsii.Number(443)))

Project File System Location EFS

Add support for CodeBuild to build on AWS EFS file system mounts using the new ProjectFileSystemLocation. The fileSystemLocations property which accepts a list ProjectFileSystemLocation as represented by the interface IFileSystemLocations. The only supported file system type is EFS.

For example:

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),
	fileSystemLocations: []iFileSystemLocation{
		codebuild.fileSystemLocation.efs(&efsFileSystemLocationProps{
			identifier: jsii.String("myidentifier2"),
			location: jsii.String("myclodation.mydnsroot.com:/loc"),
			mountPoint: jsii.String("/media"),
			mountOptions: jsii.String("opts"),
		}),
	},
})

Here's a CodeBuild project with a simple example that creates a project mounted on AWS EFS:

Minimal Example

Batch builds

To enable batch builds you should call enableBatchBuilds() on the project instance.

It returns an object containing the batch service role that was created, or undefined if batch builds could not be enabled, for example if the project was imported.

var source source


project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	source: source,
})

if project.enableBatchBuilds() {
	fmt.Println("Batch builds were enabled")
}

Timeouts

There are two types of timeouts that can be set when creating your Project. The timeout property can be used to set an upper limit on how long your Project is able to run without being marked as completed. The default is 60 minutes. An example of overriding the default follows.

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	timeout: awscdk.Duration.minutes(jsii.Number(90)),
})

The queuedTimeout property can be used to set an upper limit on how your Project remains queued to run. There is no default value for this property. As an example, to allow your Project to queue for up to thirty (30) minutes before the build fails, use the following code.

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	queuedTimeout: awscdk.Duration.minutes(jsii.Number(30)),
})

Limiting concurrency

By default if a new build is triggered it will be run even if there is a previous build already in progress. It is possible to limit the maximum concurrent builds to value between 1 and the account specific maximum limit. By default there is no explicit limit.

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	concurrentBuildLimit: jsii.Number(1),
})

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func BitBucketSourceCredentials_IsConstruct 

func BitBucketSourceCredentials_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func BitBucketSourceCredentials_IsResource 

func BitBucketSourceCredentials_IsResource(construct awscdk.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func CfnProject_CFN_RESOURCE_TYPE_NAME 

func CfnProject_CFN_RESOURCE_TYPE_NAME() *string

func CfnProject_IsCfnElement 

func CfnProject_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. Experimental.

func CfnProject_IsCfnResource 

func CfnProject_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource. Experimental.

func CfnProject_IsConstruct 

func CfnProject_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func CfnReportGroup_CFN_RESOURCE_TYPE_NAME 

func CfnReportGroup_CFN_RESOURCE_TYPE_NAME() *string

func CfnReportGroup_IsCfnElement 

func CfnReportGroup_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. Experimental.

func CfnReportGroup_IsCfnResource 

func CfnReportGroup_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource. Experimental.

func CfnReportGroup_IsConstruct 

func CfnReportGroup_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func CfnSourceCredential_CFN_RESOURCE_TYPE_NAME 

func CfnSourceCredential_CFN_RESOURCE_TYPE_NAME() *string

func CfnSourceCredential_IsCfnElement 

func CfnSourceCredential_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. Experimental.

func CfnSourceCredential_IsCfnResource 

func CfnSourceCredential_IsCfnResource(construct constructs.IConstruct) *bool

Check whether the given construct is a CfnResource. Experimental.

func CfnSourceCredential_IsConstruct 

func CfnSourceCredential_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func GitHubEnterpriseSourceCredentials_IsConstruct 

func GitHubEnterpriseSourceCredentials_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func GitHubEnterpriseSourceCredentials_IsResource 

func GitHubEnterpriseSourceCredentials_IsResource(construct awscdk.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func GitHubSourceCredentials_IsConstruct 

func GitHubSourceCredentials_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func GitHubSourceCredentials_IsResource 

func GitHubSourceCredentials_IsResource(construct awscdk.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func NewArtifacts_Override 

func NewArtifacts_Override(a Artifacts, props *ArtifactsProps)

Experimental.

func NewBitBucketSourceCredentials_Override 

func NewBitBucketSourceCredentials_Override(b BitBucketSourceCredentials, scope constructs.Construct, id *string, props *BitBucketSourceCredentialsProps)

Experimental.

func NewBuildSpec_Override 

func NewBuildSpec_Override(b BuildSpec)

Experimental.

func NewCache_Override 

func NewCache_Override(c Cache)

Experimental.

func NewCfnProject_Override 

func NewCfnProject_Override(c CfnProject, scope awscdk.Construct, id *string, props *CfnProjectProps)

Create a new `AWS::CodeBuild::Project`.

func NewCfnReportGroup_Override 

func NewCfnReportGroup_Override(c CfnReportGroup, scope awscdk.Construct, id *string, props *CfnReportGroupProps)

Create a new `AWS::CodeBuild::ReportGroup`.

func NewCfnSourceCredential_Override 

func NewCfnSourceCredential_Override(c CfnSourceCredential, scope awscdk.Construct, id *string, props *CfnSourceCredentialProps)

Create a new `AWS::CodeBuild::SourceCredential`.

func NewFileSystemLocation_Override 

func NewFileSystemLocation_Override(f FileSystemLocation)

Experimental.

func NewGitHubEnterpriseSourceCredentials_Override 

func NewGitHubEnterpriseSourceCredentials_Override(g GitHubEnterpriseSourceCredentials, scope constructs.Construct, id *string, props *GitHubEnterpriseSourceCredentialsProps)

Experimental.

func NewGitHubSourceCredentials_Override 

func NewGitHubSourceCredentials_Override(g GitHubSourceCredentials, scope constructs.Construct, id *string, props *GitHubSourceCredentialsProps)

Experimental.

func NewPipelineProject_Override 

func NewPipelineProject_Override(p PipelineProject, scope constructs.Construct, id *string, props *PipelineProjectProps)

Experimental.

func NewProject_Override 

func NewProject_Override(p Project, scope constructs.Construct, id *string, props *ProjectProps)

Experimental.

func NewReportGroup_Override 

func NewReportGroup_Override(r ReportGroup, scope constructs.Construct, id *string, props *ReportGroupProps)

Experimental.

func NewSource_Override 

func NewSource_Override(s Source, props *SourceProps)

Experimental.

func NewUntrustedCodeBoundaryPolicy_Override 

func NewUntrustedCodeBoundaryPolicy_Override(u UntrustedCodeBoundaryPolicy, scope constructs.Construct, id *string, props *UntrustedCodeBoundaryPolicyProps)

Experimental.

func PhaseChangeEvent_BuildComplete 

func PhaseChangeEvent_BuildComplete() *string

func PhaseChangeEvent_BuildId 

func PhaseChangeEvent_BuildId() *string

func PhaseChangeEvent_CompletedPhase 

func PhaseChangeEvent_CompletedPhase() *string

func PhaseChangeEvent_CompletedPhaseDurationSeconds 

func PhaseChangeEvent_CompletedPhaseDurationSeconds() *string

func PhaseChangeEvent_CompletedPhaseStatus 

func PhaseChangeEvent_CompletedPhaseStatus() *string

func PhaseChangeEvent_ProjectName 

func PhaseChangeEvent_ProjectName() *string

func PipelineProject_IsConstruct 

func PipelineProject_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func PipelineProject_IsResource 

func PipelineProject_IsResource(construct awscdk.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func PipelineProject_SerializeEnvVariables 

func PipelineProject_SerializeEnvVariables(environmentVariables *map[string]*BuildEnvironmentVariable, validateNoPlainTextSecrets *bool, principal awsiam.IGrantable) *[]*CfnProject_EnvironmentVariableProperty

Convert the environment variables map of string to {@link BuildEnvironmentVariable}, which is the customer-facing type, to a list of {@link CfnProject.EnvironmentVariableProperty}, which is the representation of environment variables in CloudFormation.

Returns: an array of {@link CfnProject.EnvironmentVariableProperty} instances Experimental.

func Project_IsConstruct 

func Project_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func Project_IsResource 

func Project_IsResource(construct awscdk.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func Project_SerializeEnvVariables 

func Project_SerializeEnvVariables(environmentVariables *map[string]*BuildEnvironmentVariable, validateNoPlainTextSecrets *bool, principal awsiam.IGrantable) *[]*CfnProject_EnvironmentVariableProperty

Convert the environment variables map of string to {@link BuildEnvironmentVariable}, which is the customer-facing type, to a list of {@link CfnProject.EnvironmentVariableProperty}, which is the representation of environment variables in CloudFormation.

Returns: an array of {@link CfnProject.EnvironmentVariableProperty} instances Experimental.

func ReportGroup_IsConstruct 

func ReportGroup_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func ReportGroup_IsResource 

func ReportGroup_IsResource(construct awscdk.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

func StateChangeEvent_BuildId 

func StateChangeEvent_BuildId() *string

func StateChangeEvent_BuildStatus 

func StateChangeEvent_BuildStatus() *string

func StateChangeEvent_CurrentPhase 

func StateChangeEvent_CurrentPhase() *string

func StateChangeEvent_ProjectName 

func StateChangeEvent_ProjectName() *string

func UntrustedCodeBoundaryPolicy_FromAwsManagedPolicyName 

func UntrustedCodeBoundaryPolicy_FromAwsManagedPolicyName(managedPolicyName *string) awsiam.IManagedPolicy

Import a managed policy from one of the policies that AWS manages.

For this managed policy, you only need to know the name to be able to use it.

Some managed policy names start with "service-role/", some start with "job-function/", and some don't start with anything. Include the prefix when constructing this object. Experimental.

func UntrustedCodeBoundaryPolicy_FromManagedPolicyArn 

func UntrustedCodeBoundaryPolicy_FromManagedPolicyArn(scope constructs.Construct, id *string, managedPolicyArn *string) awsiam.IManagedPolicy

Import an external managed policy by ARN.

For this managed policy, you only need to know the ARN to be able to use it. This can be useful if you got the ARN from a CloudFormation Export.

If the imported Managed Policy ARN is a Token (such as a `CfnParameter.valueAsString` or a `Fn.importValue()`) *and* the referenced managed policy has a `path` (like `arn:...:policy/AdminPolicy/AdminAllow`), the `managedPolicyName` property will not resolve to the correct value. Instead it will resolve to the first path component. We unfortunately cannot express the correct calculation of the full path name as a CloudFormation expression. In this scenario the Managed Policy ARN should be supplied without the `path` in order to resolve the correct managed policy resource. Experimental.

func UntrustedCodeBoundaryPolicy_FromManagedPolicyName 

func UntrustedCodeBoundaryPolicy_FromManagedPolicyName(scope constructs.Construct, id *string, managedPolicyName *string) awsiam.IManagedPolicy

Import a customer managed policy from the managedPolicyName.

For this managed policy, you only need to know the name to be able to use it. Experimental.

func UntrustedCodeBoundaryPolicy_IsConstruct 

func UntrustedCodeBoundaryPolicy_IsConstruct(x interface{}) *bool

Return whether the given object is a Construct. Experimental.

func UntrustedCodeBoundaryPolicy_IsResource 

func UntrustedCodeBoundaryPolicy_IsResource(construct awscdk.IConstruct) *bool

Check whether the given construct is a Resource. Experimental.

Types

type Artifacts 

type Artifacts interface {
	IArtifacts
	// The artifact identifier.
	//
	// This property is required on secondary artifacts.
	// Experimental.
	Identifier() *string
	// The CodeBuild type of this artifact.
	// Experimental.
	Type() *string
	// Callback when an Artifacts class is used in a CodeBuild Project.
	// Experimental.
	Bind(_scope awscdk.Construct, _project IProject) *ArtifactsConfig
}

Artifacts definition for a CodeBuild Project.

Example: 

var bucket bucket

project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),
	artifacts: codebuild.artifacts.s3(&s3ArtifactsProps{
		bucket: bucket,
		includeBuildId: jsii.Boolean(false),
		packageZip: jsii.Boolean(true),
		path: jsii.String("another/path"),
		identifier: jsii.String("AddArtifact1"),
	}),
})

Experimental.

type ArtifactsConfig 

type ArtifactsConfig struct {
	// The low-level CloudFormation artifacts property.
	// Experimental.
	ArtifactsProperty *CfnProject_ArtifactsProperty `field:"required" json:"artifactsProperty" yaml:"artifactsProperty"`
}

The type returned from {@link IArtifacts#bind}.

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"

artifactsConfig := &artifactsConfig{
	artifactsProperty: &artifactsProperty{
		type: jsii.String("type"),

		// the properties below are optional
		artifactIdentifier: jsii.String("artifactIdentifier"),
		encryptionDisabled: jsii.Boolean(false),
		location: jsii.String("location"),
		name: jsii.String("name"),
		namespaceType: jsii.String("namespaceType"),
		overrideArtifactName: jsii.Boolean(false),
		packaging: jsii.String("packaging"),
		path: jsii.String("path"),
	},
}

Experimental.

type ArtifactsProps 

type ArtifactsProps struct {
	// The artifact identifier.
	//
	// This property is required on secondary artifacts.
	// Experimental.
	Identifier *string `field:"optional" json:"identifier" yaml:"identifier"`
}

Properties common to all Artifacts classes.

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"

artifactsProps := &artifactsProps{
	identifier: jsii.String("identifier"),
}

Experimental.

type BatchBuildConfig 

type BatchBuildConfig struct {
	// The IAM batch service Role of this Project.
	// Experimental.
	Role awsiam.IRole `field:"required" json:"role" yaml:"role"`
}

The type returned from {@link IProject#enableBatchBuilds}.

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

batchBuildConfig := &batchBuildConfig{
	role: role,
}

Experimental.

type BindToCodePipelineOptions 

type BindToCodePipelineOptions struct {
	// The artifact bucket that will be used by the action that invokes this project.
	// Experimental.
	ArtifactBucket awss3.IBucket `field:"required" json:"artifactBucket" yaml:"artifactBucket"`
}

The extra options passed to the {@link IProject.bindToCodePipeline} method.

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

bindToCodePipelineOptions := &bindToCodePipelineOptions{
	artifactBucket: bucket,
}

Experimental.

type BitBucketSourceCredentials 

type BitBucketSourceCredentials interface {
	awscdk.Resource
	// 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.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// 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.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// 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`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	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`.
	// Experimental.
	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.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	Validate() *[]*string
}

The source credentials used when contacting the BitBucket API.

**Note**: CodeBuild only allows a single credential for BitBucket to be saved in a given AWS account in a given region - any attempt to add more than one will result in an error.

Example: 

codebuild.NewBitBucketSourceCredentials(this, jsii.String("CodeBuildBitBucketCreds"), &bitBucketSourceCredentialsProps{
	username: awscdk.SecretValue.secretsManager(jsii.String("my-bitbucket-creds"), &secretsManagerSecretOptions{
		jsonField: jsii.String("username"),
	}),
	password: awscdk.SecretValue.secretsManager(jsii.String("my-bitbucket-creds"), &secretsManagerSecretOptions{
		jsonField: jsii.String("password"),
	}),
})

Experimental.

func NewBitBucketSourceCredentials 

func NewBitBucketSourceCredentials(scope constructs.Construct, id *string, props *BitBucketSourceCredentialsProps) BitBucketSourceCredentials

Experimental.

type BitBucketSourceCredentialsProps 

type BitBucketSourceCredentialsProps struct {
	// Your BitBucket application password.
	// Experimental.
	Password awscdk.SecretValue `field:"required" json:"password" yaml:"password"`
	// Your BitBucket username.
	// Experimental.
	Username awscdk.SecretValue `field:"required" json:"username" yaml:"username"`
}

Construction properties of {@link BitBucketSourceCredentials}.

Example: 

codebuild.NewBitBucketSourceCredentials(this, jsii.String("CodeBuildBitBucketCreds"), &bitBucketSourceCredentialsProps{
	username: awscdk.SecretValue.secretsManager(jsii.String("my-bitbucket-creds"), &secretsManagerSecretOptions{
		jsonField: jsii.String("username"),
	}),
	password: awscdk.SecretValue.secretsManager(jsii.String("my-bitbucket-creds"), &secretsManagerSecretOptions{
		jsonField: jsii.String("password"),
	}),
})

Experimental.

type BitBucketSourceProps 

type BitBucketSourceProps struct {
	// The source identifier.
	//
	// This property is required on secondary sources.
	// Experimental.
	Identifier *string `field:"optional" json:"identifier" yaml:"identifier"`
	// The BitBucket account/user that owns the repo.
	//
	// Example:
	//   "awslabs"
	//
	// Experimental.
	Owner *string `field:"required" json:"owner" yaml:"owner"`
	// The name of the repo (without the username).
	//
	// Example:
	//   "aws-cdk"
	//
	// Experimental.
	Repo *string `field:"required" json:"repo" yaml:"repo"`
	// The commit ID, pull request ID, branch name, or tag name that corresponds to the version of the source code you want to build.
	//
	// Example:
	//   "mybranch"
	//
	// Experimental.
	BranchOrRef *string `field:"optional" json:"branchOrRef" yaml:"branchOrRef"`
	// This parameter is used for the `name` parameter in the Bitbucket commit status.
	//
	// Can use built-in CodeBuild variables, like $AWS_REGION.
	//
	// Example:
	//   "My build #$CODEBUILD_BUILD_NUMBER"
	//
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
	//
	// Experimental.
	BuildStatusName *string `field:"optional" json:"buildStatusName" yaml:"buildStatusName"`
	// The URL that the build will report back to the source provider.
	//
	// Can use built-in CodeBuild variables, like $AWS_REGION.
	//
	// Example:
	//   "$CODEBUILD_PUBLIC_BUILD_URL"
	//
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
	//
	// Experimental.
	BuildStatusUrl *string `field:"optional" json:"buildStatusUrl" yaml:"buildStatusUrl"`
	// The depth of history to download.
	//
	// Minimum value is 0.
	// If this value is 0, greater than 25, or not provided,
	// then the full history is downloaded with each build of the project.
	// Experimental.
	CloneDepth *float64 `field:"optional" json:"cloneDepth" yaml:"cloneDepth"`
	// Whether to fetch submodules while cloning git repo.
	// Experimental.
	FetchSubmodules *bool `field:"optional" json:"fetchSubmodules" yaml:"fetchSubmodules"`
	// Whether to send notifications on your build's start and end.
	// Experimental.
	ReportBuildStatus *bool `field:"optional" json:"reportBuildStatus" yaml:"reportBuildStatus"`
	// Whether to create a webhook that will trigger a build every time an event happens in the repository.
	// Experimental.
	Webhook *bool `field:"optional" json:"webhook" yaml:"webhook"`
	// A list of webhook filters that can constraint what events in the repository will trigger a build.
	//
	// A build is triggered if any of the provided filter groups match.
	// Only valid if `webhook` was not provided as false.
	// Experimental.
	WebhookFilters *[]FilterGroup `field:"optional" json:"webhookFilters" yaml:"webhookFilters"`
	// Trigger a batch build from a webhook instead of a standard one.
	//
	// Enabling this will enable batch builds on the CodeBuild project.
	// Experimental.
	WebhookTriggersBatchBuild *bool `field:"optional" json:"webhookTriggersBatchBuild" yaml:"webhookTriggersBatchBuild"`
}

Construction properties for {@link BitBucketSource}.

Example: 

bbSource := codebuild.source.bitBucket(&bitBucketSourceProps{
	owner: jsii.String("owner"),
	repo: jsii.String("repo"),
})

Experimental.

type BucketCacheOptions 

type BucketCacheOptions struct {
	// The prefix to use to store the cache in the bucket.
	// Experimental.
	Prefix *string `field:"optional" json:"prefix" yaml:"prefix"`
}

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"

bucketCacheOptions := &bucketCacheOptions{
	prefix: jsii.String("prefix"),
}

Experimental.

type BuildEnvironment 

type BuildEnvironment struct {
	// The image used for the builds.
	// Experimental.
	BuildImage IBuildImage `field:"optional" json:"buildImage" yaml:"buildImage"`
	// The location of the PEM-encoded certificate for the build project.
	// Experimental.
	Certificate *BuildEnvironmentCertificate `field:"optional" json:"certificate" yaml:"certificate"`
	// The type of compute to use for this build.
	//
	// See the {@link ComputeType} enum for the possible values.
	// Experimental.
	ComputeType ComputeType `field:"optional" json:"computeType" yaml:"computeType"`
	// The environment variables that your builds can use.
	// Experimental.
	EnvironmentVariables *map[string]*BuildEnvironmentVariable `field:"optional" json:"environmentVariables" yaml:"environmentVariables"`
	// Indicates how the project builds Docker images.
	//
	// Specify true to enable
	// running the Docker daemon inside a Docker container. This value must be
	// set to true only if this build project will be used to build Docker
	// images, and the specified build environment image is not one provided by
	// AWS CodeBuild with Docker support. Otherwise, all associated builds that
	// attempt to interact with the Docker daemon will fail.
	// Experimental.
	Privileged *bool `field:"optional" json:"privileged" yaml:"privileged"`
}

Example: 

var vpc vpc
var mySecurityGroup securityGroup

pipelines.NewCodePipeline(this, jsii.String("Pipeline"), &codePipelineProps{
	// Standard CodePipeline properties
	synth: pipelines.NewShellStep(jsii.String("Synth"), &shellStepProps{
		input: pipelines.codePipelineSource.connection(jsii.String("my-org/my-app"), jsii.String("main"), &connectionSourceOptions{
			connectionArn: jsii.String("arn:aws:codestar-connections:us-east-1:222222222222:connection/7d2469ff-514a-4e4f-9003-5ca4a43cdc41"),
		}),
		commands: []*string{
			jsii.String("npm ci"),
			jsii.String("npm run build"),
			jsii.String("npx cdk synth"),
		},
	}),

	// Defaults for all CodeBuild projects
	codeBuildDefaults: &codeBuildOptions{
		// Prepend commands and configuration to all projects
		partialBuildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
			"version": jsii.String("0.2"),
		}),

		// Control the build environment
		buildEnvironment: &buildEnvironment{
			computeType: codebuild.computeType_LARGE,
		},

		// Control Elastic Network Interface creation
		vpc: vpc,
		subnetSelection: &subnetSelection{
			subnetType: ec2.subnetType_PRIVATE_WITH_NAT,
		},
		securityGroups: []iSecurityGroup{
			mySecurityGroup,
		},

		// Additional policy statements for the execution role
		rolePolicy: []policyStatement{
			iam.NewPolicyStatement(&policyStatementProps{
			}),
		},
	},

	synthCodeBuildDefaults: &codeBuildOptions{
	},
	assetPublishingCodeBuildDefaults: &codeBuildOptions{
	},
	selfMutationCodeBuildDefaults: &codeBuildOptions{
	},
})

Experimental.

type BuildEnvironmentCertificate 

type BuildEnvironmentCertificate struct {
	// The bucket where the certificate is.
	// Experimental.
	Bucket awss3.IBucket `field:"required" json:"bucket" yaml:"bucket"`
	// The full path and name of the key file.
	// Experimental.
	ObjectKey *string `field:"required" json:"objectKey" yaml:"objectKey"`
}

Location of a PEM certificate on S3.

Example: 

var ecrRepository repository

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	environment: &buildEnvironment{
		buildImage: codebuild.windowsBuildImage.fromEcrRepository(ecrRepository, jsii.String("v1.0"), codebuild.windowsImageType_SERVER_2019),
		// optional certificate to include in the build image
		certificate: &buildEnvironmentCertificate{
			bucket: s3.bucket.fromBucketName(this, jsii.String("Bucket"), jsii.String("my-bucket")),
			objectKey: jsii.String("path/to/cert.pem"),
		},
	},
})

Experimental.

type BuildEnvironmentVariable 

type BuildEnvironmentVariable struct {
	// The value of the environment variable.
	//
	// For plain-text variables (the default), this is the literal value of variable.
	// For SSM parameter variables, pass the name of the parameter here (`parameterName` property of `IParameter`).
	// For SecretsManager variables secrets, pass either the secret name (`secretName` property of `ISecret`)
	// or the secret ARN (`secretArn` property of `ISecret`) here,
	// along with optional SecretsManager qualifiers separated by ':', like the JSON key, or the version or stage
	// (see https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec.env.secrets-manager for details).
	// Experimental.
	Value interface{} `field:"required" json:"value" yaml:"value"`
	// The type of environment variable.
	// Experimental.
	Type BuildEnvironmentVariableType `field:"optional" json:"type" yaml:"type"`
}

Example: 

// later:
var project pipelineProject
sourceOutput := codepipeline.NewArtifact()
buildAction := codepipeline_actions.NewCodeBuildAction(&codeBuildActionProps{
	actionName: jsii.String("Build1"),
	input: sourceOutput,
	project: codebuild.NewPipelineProject(this, jsii.String("Project"), &pipelineProjectProps{
		buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
			"version": jsii.String("0.2"),
			"env": map[string][]*string{
				"exported-variables": []*string{
					jsii.String("MY_VAR"),
				},
			},
			"phases": map[string]map[string]*string{
				"build": map[string]*string{
					"commands": jsii.String("export MY_VAR=\"some value\""),
				},
			},
		}),
	}),
	variablesNamespace: jsii.String("MyNamespace"),
})
codepipeline_actions.NewCodeBuildAction(&codeBuildActionProps{
	actionName: jsii.String("CodeBuild"),
	project: project,
	input: sourceOutput,
	environmentVariables: map[string]buildEnvironmentVariable{
		"MyVar": &buildEnvironmentVariable{
			"value": buildAction.variable(jsii.String("MY_VAR")),
		},
	},
})

Experimental.

type BuildEnvironmentVariableType 

type BuildEnvironmentVariableType string

Example: 

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

codebuildProject := codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	projectName: jsii.String("MyTestProject"),
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("echo \"Hello, CodeBuild!\""),
				},
			},
		},
	}),
})

task := tasks.NewCodeBuildStartBuild(this, jsii.String("Task"), &codeBuildStartBuildProps{
	project: codebuildProject,
	integrationPattern: sfn.integrationPattern_RUN_JOB,
	environmentVariablesOverride: map[string]buildEnvironmentVariable{
		"ZONE": &buildEnvironmentVariable{
			"type": codebuild.BuildEnvironmentVariableType_PLAINTEXT,
			"value": sfn.JsonPath.stringAt(jsii.String("$.envVariables.zone")),
		},
	},
})

Experimental. 

const (
	// An environment variable in plaintext format.
	// Experimental.
	BuildEnvironmentVariableType_PLAINTEXT BuildEnvironmentVariableType = "PLAINTEXT"
	// An environment variable stored in Systems Manager Parameter Store.
	// Experimental.
	BuildEnvironmentVariableType_PARAMETER_STORE BuildEnvironmentVariableType = "PARAMETER_STORE"
	// An environment variable stored in AWS Secrets Manager.
	// Experimental.
	BuildEnvironmentVariableType_SECRETS_MANAGER BuildEnvironmentVariableType = "SECRETS_MANAGER"
)

type BuildImageBindOptions 

type BuildImageBindOptions struct {
}

Optional arguments to {@link IBuildImage.binder} - currently empty.

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"

buildImageBindOptions := &buildImageBindOptions{
}

Experimental.

type BuildImageConfig 

type BuildImageConfig struct {
}

The return type from {@link IBuildImage.binder} - currently empty.

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"

buildImageConfig := &buildImageConfig{
}

Experimental.

type BuildSpec 

type BuildSpec interface {
	// Whether the buildspec is directly available or deferred until build-time.
	// Experimental.
	IsImmediate() *bool
	// Render the represented BuildSpec.
	// Experimental.
	ToBuildSpec() *string
}

BuildSpec for CodeBuild projects.

Example: 

// later:
var project pipelineProject
sourceOutput := codepipeline.NewArtifact()
buildAction := codepipeline_actions.NewCodeBuildAction(&codeBuildActionProps{
	actionName: jsii.String("Build1"),
	input: sourceOutput,
	project: codebuild.NewPipelineProject(this, jsii.String("Project"), &pipelineProjectProps{
		buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
			"version": jsii.String("0.2"),
			"env": map[string][]*string{
				"exported-variables": []*string{
					jsii.String("MY_VAR"),
				},
			},
			"phases": map[string]map[string]*string{
				"build": map[string]*string{
					"commands": jsii.String("export MY_VAR=\"some value\""),
				},
			},
		}),
	}),
	variablesNamespace: jsii.String("MyNamespace"),
})
codepipeline_actions.NewCodeBuildAction(&codeBuildActionProps{
	actionName: jsii.String("CodeBuild"),
	project: project,
	input: sourceOutput,
	environmentVariables: map[string]buildEnvironmentVariable{
		"MyVar": &buildEnvironmentVariable{
			"value": buildAction.variable(jsii.String("MY_VAR")),
		},
	},
})

Experimental.

func BuildSpec_FromObject 

func BuildSpec_FromObject(value *map[string]interface{}) BuildSpec

Experimental.

func BuildSpec_FromObjectToYaml 

func BuildSpec_FromObjectToYaml(value *map[string]interface{}) BuildSpec

Create a buildspec from an object that will be rendered as YAML in the resulting CloudFormation template. Experimental.

func BuildSpec_FromSourceFilename 

func BuildSpec_FromSourceFilename(filename *string) BuildSpec

Use a file from the source as buildspec.

Use this if you want to use a file different from 'buildspec.yml'` Experimental.

type Cache 

type Cache interface {
}

Cache options for CodeBuild Project.

A cache can store reusable pieces of your build environment and use them across multiple builds.

Example: 

var myCachingBucket bucket

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	source: codebuild.source.bitBucket(&bitBucketSourceProps{
		owner: jsii.String("awslabs"),
		repo: jsii.String("aws-cdk"),
	}),

	cache: codebuild.cache.bucket(myCachingBucket),

	// BuildSpec with a 'cache' section necessary for S3 caching. This can
	// also come from 'buildspec.yml' in your source.
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("..."),
				},
			},
		},
		"cache": map[string][]*string{
			"paths": []*string{
				jsii.String("/root/cachedir/**/*"),
			},
		},
	}),
})

See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-caching.html

Experimental.

func Cache_Bucket 

func Cache_Bucket(bucket awss3.IBucket, options *BucketCacheOptions) Cache

Create an S3 caching strategy. Experimental.

func Cache_Local 

func Cache_Local(modes ...LocalCacheMode) Cache

Create a local caching strategy. Experimental.

func Cache_None 

func Cache_None() Cache

Experimental.

type CfnProject 

type CfnProject interface {
	awscdk.CfnResource
	awscdk.IInspectable
	// `Artifacts` is a property of the [AWS::CodeBuild::Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that specifies output settings for artifacts generated by an AWS CodeBuild build.
	Artifacts() interface{}
	SetArtifacts(val interface{})
	// The ARN of the AWS CodeBuild project, such as `arn:aws:codebuild:us-west-2:123456789012:project/myProjectName` .
	AttrArn() *string
	// Indicates whether AWS CodeBuild generates a publicly accessible URL for your project's build badge.
	//
	// For more information, see [Build Badges Sample](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-badges.html) in the *AWS CodeBuild User Guide* .
	//
	// > Including build badges with your project is currently not supported if the source type is CodePipeline. If you specify `CODEPIPELINE` for the `Source` property, do not specify the `BadgeEnabled` property.
	BadgeEnabled() interface{}
	SetBadgeEnabled(val interface{})
	// A `ProjectBuildBatchConfig` object that defines the batch build options for the project.
	BuildBatchConfig() interface{}
	SetBuildBatchConfig(val interface{})
	// Settings that AWS CodeBuild uses to store and reuse build dependencies.
	Cache() interface{}
	SetCache(val interface{})
	// Options for this resource, such as condition, update policy etc.
	// Experimental.
	CfnOptions() awscdk.ICfnResourceOptions
	CfnProperties() *map[string]interface{}
	// AWS resource type.
	// Experimental.
	CfnResourceType() *string
	// The maximum number of concurrent builds that are allowed for this project.
	//
	// New builds are only started if the current number of builds is less than or equal to this limit. If the current build count meets this limit, new builds are throttled and are not run.
	ConcurrentBuildLimit() *float64
	SetConcurrentBuildLimit(val *float64)
	// 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.
	// Experimental.
	CreationStack() *[]*string
	// A description that makes the build project easy to identify.
	Description() *string
	SetDescription(val *string)
	// The AWS Key Management Service customer master key (CMK) to be used for encrypting the build output artifacts.
	//
	// > You can use a cross-account KMS key to encrypt the build output artifacts if your service role has permission to that key.
	//
	// You can specify either the Amazon Resource Name (ARN) of the CMK or, if available, the CMK's alias (using the format `alias/<alias-name>` ). If you don't specify a value, CodeBuild uses the managed CMK for Amazon Simple Storage Service (Amazon S3).
	EncryptionKey() *string
	SetEncryptionKey(val *string)
	// The build environment settings for the project, such as the environment type or the environment variables to use for the build environment.
	Environment() interface{}
	SetEnvironment(val interface{})
	// An array of `ProjectFileSystemLocation` objects for a CodeBuild build project.
	//
	// A `ProjectFileSystemLocation` object specifies the `identifier` , `location` , `mountOptions` , `mountPoint` , and `type` of a file system created using Amazon Elastic File System.
	FileSystemLocations() interface{}
	SetFileSystemLocations(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.
	// Experimental.
	LogicalId() *string
	// Information about logs for the build project.
	//
	// A project can create logs in CloudWatch Logs, an S3 bucket, or both.
	LogsConfig() interface{}
	SetLogsConfig(val interface{})
	// The name of the build project.
	//
	// The name must be unique across all of the projects in your AWS account .
	Name() *string
	SetName(val *string)
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// The number of minutes a build is allowed to be queued before it times out.
	QueuedTimeoutInMinutes() *float64
	SetQueuedTimeoutInMinutes(val *float64)
	// 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 })`.
	// Experimental.
	Ref() *string
	// The ARN of the IAM role that enables CodeBuild to access the CloudWatch Logs and Amazon S3 artifacts for the project's builds.
	ResourceAccessRole() *string
	SetResourceAccessRole(val *string)
	// A list of `Artifacts` objects.
	//
	// Each artifacts object specifies output settings that the project generates during a build.
	SecondaryArtifacts() interface{}
	SetSecondaryArtifacts(val interface{})
	// An array of `ProjectSource` objects.
	SecondarySources() interface{}
	SetSecondarySources(val interface{})
	// An array of `ProjectSourceVersion` objects.
	//
	// If `secondarySourceVersions` is specified at the build level, then they take over these `secondarySourceVersions` (at the project level).
	SecondarySourceVersions() interface{}
	SetSecondarySourceVersions(val interface{})
	// The ARN of the IAM role that enables AWS CodeBuild to interact with dependent AWS services on behalf of the AWS account.
	ServiceRole() *string
	SetServiceRole(val *string)
	// The source code settings for the project, such as the source code's repository type and location.
	Source() interface{}
	SetSource(val interface{})
	// A version of the build input to be built for this project.
	//
	// If not specified, the latest version is used. If specified, it must be one of:
	//
	// - For CodeCommit: the commit ID, branch, or Git tag to use.
	// - For GitHub: the commit ID, pull request ID, branch name, or tag name that corresponds to the version of the source code you want to build. If a pull request ID is specified, it must use the format `pr/pull-request-ID` (for example `pr/25` ). If a branch name is specified, the branch's HEAD commit ID is used. If not specified, the default branch's HEAD commit ID is used.
	// - For Bitbucket: the commit ID, branch name, or tag name that corresponds to the version of the source code you want to build. If a branch name is specified, the branch's HEAD commit ID is used. If not specified, the default branch's HEAD commit ID is used.
	// - For Amazon S3: the version ID of the object that represents the build input ZIP file to use.
	//
	// If `sourceVersion` is specified at the build level, then that version takes precedence over this `sourceVersion` (at the project level).
	//
	// For more information, see [Source Version Sample with CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-source-version.html) in the *AWS CodeBuild User Guide* .
	SourceVersion() *string
	SetSourceVersion(val *string)
	// The stack in which this element is defined.
	//
	// CfnElements must be defined within a stack scope (directly or indirectly).
	// Experimental.
	Stack() awscdk.Stack
	// An arbitrary set of tags (key-value pairs) for the AWS CodeBuild project.
	//
	// These tags are available for use by AWS services that support AWS CodeBuild build project tags.
	Tags() awscdk.TagManager
	// How long, in minutes, from 5 to 480 (8 hours), for AWS CodeBuild to wait before timing out any related build that did not get marked as completed.
	//
	// The default is 60 minutes.
	TimeoutInMinutes() *float64
	SetTimeoutInMinutes(val *float64)
	// For an existing AWS CodeBuild build project that has its source code stored in a GitHub repository, enables AWS CodeBuild to begin automatically rebuilding the source code every time a code change is pushed to the repository.
	Triggers() interface{}
	SetTriggers(val 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.
	// Experimental.
	UpdatedProperites() *map[string]interface{}
	// Specifies the visibility of the project's builds. Possible values are:.
	//
	// - **PUBLIC_READ** - The project builds are visible to the public.
	// - **PRIVATE** - The project builds are not visible to the public.
	Visibility() *string
	SetVisibility(val *string)
	// `VpcConfig` specifies settings that enable AWS CodeBuild to access resources in an Amazon VPC.
	//
	// For more information, see [Use AWS CodeBuild with Amazon Virtual Private Cloud](https://docs.aws.amazon.com/codebuild/latest/userguide/vpc-support.html) in the *AWS CodeBuild User Guide* .
	VpcConfig() interface{}
	SetVpcConfig(val interface{})
	// Syntactic sugar for `addOverride(path, undefined)`.
	// Experimental.
	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.
	// Experimental.
	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.
	//
	// Experimental.
	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.
	// Experimental.
	AddOverride(path *string, value interface{})
	// Adds an override that deletes the value of a property from the resource definition.
	// Experimental.
	AddPropertyDeletionOverride(propertyPath *string)
	// Adds an override to a resource property.
	//
	// Syntactic sugar for `addOverride("Properties.<...>", value)`.
	// Experimental.
	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`).
	// Experimental.
	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.
	// Experimental.
	GetAtt(attributeName *string) 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.
	//
	// Experimental.
	GetMetadata(key *string) interface{}
	// Examines the CloudFormation resource and discloses attributes.
	Inspect(inspector awscdk.TreeInspector)
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Overrides the auto-generated logical ID with a specific ID.
	// Experimental.
	OverrideLogicalId(newLogicalId *string)
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	RenderProperties(props *map[string]interface{}) *map[string]interface{}
	// 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.
	// Experimental.
	ShouldSynthesize() *bool
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	//
	// Returns: a string representation of this resource.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	Validate() *[]*string
	// Experimental.
	ValidateProperties(_properties interface{})
}

A CloudFormation `AWS::CodeBuild::Project`.

The `AWS::CodeBuild::Project` resource configures how AWS CodeBuild builds your source code. For example, it tells CodeBuild where to get the source code and which build environment to 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"

cfnProject := awscdk.Aws_codebuild.NewCfnProject(this, jsii.String("MyCfnProject"), &cfnProjectProps{
	artifacts: &artifactsProperty{
		type: jsii.String("type"),

		// the properties below are optional
		artifactIdentifier: jsii.String("artifactIdentifier"),
		encryptionDisabled: jsii.Boolean(false),
		location: jsii.String("location"),
		name: jsii.String("name"),
		namespaceType: jsii.String("namespaceType"),
		overrideArtifactName: jsii.Boolean(false),
		packaging: jsii.String("packaging"),
		path: jsii.String("path"),
	},
	environment: &environmentProperty{
		computeType: jsii.String("computeType"),
		image: jsii.String("image"),
		type: jsii.String("type"),

		// the properties below are optional
		certificate: jsii.String("certificate"),
		environmentVariables: []interface{}{
			&environmentVariableProperty{
				name: jsii.String("name"),
				value: jsii.String("value"),

				// the properties below are optional
				type: jsii.String("type"),
			},
		},
		imagePullCredentialsType: jsii.String("imagePullCredentialsType"),
		privilegedMode: jsii.Boolean(false),
		registryCredential: &registryCredentialProperty{
			credential: jsii.String("credential"),
			credentialProvider: jsii.String("credentialProvider"),
		},
	},
	serviceRole: jsii.String("serviceRole"),
	source: &sourceProperty{
		type: jsii.String("type"),

		// the properties below are optional
		auth: &sourceAuthProperty{
			type: jsii.String("type"),

			// the properties below are optional
			resource: jsii.String("resource"),
		},
		buildSpec: jsii.String("buildSpec"),
		buildStatusConfig: &buildStatusConfigProperty{
			context: jsii.String("context"),
			targetUrl: jsii.String("targetUrl"),
		},
		gitCloneDepth: jsii.Number(123),
		gitSubmodulesConfig: &gitSubmodulesConfigProperty{
			fetchSubmodules: jsii.Boolean(false),
		},
		insecureSsl: jsii.Boolean(false),
		location: jsii.String("location"),
		reportBuildStatus: jsii.Boolean(false),
		sourceIdentifier: jsii.String("sourceIdentifier"),
	},

	// the properties below are optional
	badgeEnabled: jsii.Boolean(false),
	buildBatchConfig: &projectBuildBatchConfigProperty{
		batchReportMode: jsii.String("batchReportMode"),
		combineArtifacts: jsii.Boolean(false),
		restrictions: &batchRestrictionsProperty{
			computeTypesAllowed: []*string{
				jsii.String("computeTypesAllowed"),
			},
			maximumBuildsAllowed: jsii.Number(123),
		},
		serviceRole: jsii.String("serviceRole"),
		timeoutInMins: jsii.Number(123),
	},
	cache: &projectCacheProperty{
		type: jsii.String("type"),

		// the properties below are optional
		location: jsii.String("location"),
		modes: []*string{
			jsii.String("modes"),
		},
	},
	concurrentBuildLimit: jsii.Number(123),
	description: jsii.String("description"),
	encryptionKey: jsii.String("encryptionKey"),
	fileSystemLocations: []interface{}{
		&projectFileSystemLocationProperty{
			identifier: jsii.String("identifier"),
			location: jsii.String("location"),
			mountPoint: jsii.String("mountPoint"),
			type: jsii.String("type"),

			// the properties below are optional
			mountOptions: jsii.String("mountOptions"),
		},
	},
	logsConfig: &logsConfigProperty{
		cloudWatchLogs: &cloudWatchLogsConfigProperty{
			status: jsii.String("status"),

			// the properties below are optional
			groupName: jsii.String("groupName"),
			streamName: jsii.String("streamName"),
		},
		s3Logs: &s3LogsConfigProperty{
			status: jsii.String("status"),

			// the properties below are optional
			encryptionDisabled: jsii.Boolean(false),
			location: jsii.String("location"),
		},
	},
	name: jsii.String("name"),
	queuedTimeoutInMinutes: jsii.Number(123),
	resourceAccessRole: jsii.String("resourceAccessRole"),
	secondaryArtifacts: []interface{}{
		&artifactsProperty{
			type: jsii.String("type"),

			// the properties below are optional
			artifactIdentifier: jsii.String("artifactIdentifier"),
			encryptionDisabled: jsii.Boolean(false),
			location: jsii.String("location"),
			name: jsii.String("name"),
			namespaceType: jsii.String("namespaceType"),
			overrideArtifactName: jsii.Boolean(false),
			packaging: jsii.String("packaging"),
			path: jsii.String("path"),
		},
	},
	secondarySources: []interface{}{
		&sourceProperty{
			type: jsii.String("type"),

			// the properties below are optional
			auth: &sourceAuthProperty{
				type: jsii.String("type"),

				// the properties below are optional
				resource: jsii.String("resource"),
			},
			buildSpec: jsii.String("buildSpec"),
			buildStatusConfig: &buildStatusConfigProperty{
				context: jsii.String("context"),
				targetUrl: jsii.String("targetUrl"),
			},
			gitCloneDepth: jsii.Number(123),
			gitSubmodulesConfig: &gitSubmodulesConfigProperty{
				fetchSubmodules: jsii.Boolean(false),
			},
			insecureSsl: jsii.Boolean(false),
			location: jsii.String("location"),
			reportBuildStatus: jsii.Boolean(false),
			sourceIdentifier: jsii.String("sourceIdentifier"),
		},
	},
	secondarySourceVersions: []interface{}{
		&projectSourceVersionProperty{
			sourceIdentifier: jsii.String("sourceIdentifier"),

			// the properties below are optional
			sourceVersion: jsii.String("sourceVersion"),
		},
	},
	sourceVersion: jsii.String("sourceVersion"),
	tags: []cfnTag{
		&cfnTag{
			key: jsii.String("key"),
			value: jsii.String("value"),
		},
	},
	timeoutInMinutes: jsii.Number(123),
	triggers: &projectTriggersProperty{
		buildType: jsii.String("buildType"),
		filterGroups: []interface{}{
			[]interface{}{
				&webhookFilterProperty{
					pattern: jsii.String("pattern"),
					type: jsii.String("type"),

					// the properties below are optional
					excludeMatchedPattern: jsii.Boolean(false),
				},
			},
		},
		webhook: jsii.Boolean(false),
	},
	visibility: jsii.String("visibility"),
	vpcConfig: &vpcConfigProperty{
		securityGroupIds: []*string{
			jsii.String("securityGroupIds"),
		},
		subnets: []*string{
			jsii.String("subnets"),
		},
		vpcId: jsii.String("vpcId"),
	},
})

func NewCfnProject 

func NewCfnProject(scope awscdk.Construct, id *string, props *CfnProjectProps) CfnProject

Create a new `AWS::CodeBuild::Project`.

type CfnProjectProps 

type CfnProjectProps struct {
	// `Artifacts` is a property of the [AWS::CodeBuild::Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that specifies output settings for artifacts generated by an AWS CodeBuild build.
	Artifacts interface{} `field:"required" json:"artifacts" yaml:"artifacts"`
	// The build environment settings for the project, such as the environment type or the environment variables to use for the build environment.
	Environment interface{} `field:"required" json:"environment" yaml:"environment"`
	// The ARN of the IAM role that enables AWS CodeBuild to interact with dependent AWS services on behalf of the AWS account.
	ServiceRole *string `field:"required" json:"serviceRole" yaml:"serviceRole"`
	// The source code settings for the project, such as the source code's repository type and location.
	Source interface{} `field:"required" json:"source" yaml:"source"`
	// Indicates whether AWS CodeBuild generates a publicly accessible URL for your project's build badge.
	//
	// For more information, see [Build Badges Sample](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-badges.html) in the *AWS CodeBuild User Guide* .
	//
	// > Including build badges with your project is currently not supported if the source type is CodePipeline. If you specify `CODEPIPELINE` for the `Source` property, do not specify the `BadgeEnabled` property.
	BadgeEnabled interface{} `field:"optional" json:"badgeEnabled" yaml:"badgeEnabled"`
	// A `ProjectBuildBatchConfig` object that defines the batch build options for the project.
	BuildBatchConfig interface{} `field:"optional" json:"buildBatchConfig" yaml:"buildBatchConfig"`
	// Settings that AWS CodeBuild uses to store and reuse build dependencies.
	Cache interface{} `field:"optional" json:"cache" yaml:"cache"`
	// The maximum number of concurrent builds that are allowed for this project.
	//
	// New builds are only started if the current number of builds is less than or equal to this limit. If the current build count meets this limit, new builds are throttled and are not run.
	ConcurrentBuildLimit *float64 `field:"optional" json:"concurrentBuildLimit" yaml:"concurrentBuildLimit"`
	// A description that makes the build project easy to identify.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// The AWS Key Management Service customer master key (CMK) to be used for encrypting the build output artifacts.
	//
	// > You can use a cross-account KMS key to encrypt the build output artifacts if your service role has permission to that key.
	//
	// You can specify either the Amazon Resource Name (ARN) of the CMK or, if available, the CMK's alias (using the format `alias/<alias-name>` ). If you don't specify a value, CodeBuild uses the managed CMK for Amazon Simple Storage Service (Amazon S3).
	EncryptionKey *string `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	// An array of `ProjectFileSystemLocation` objects for a CodeBuild build project.
	//
	// A `ProjectFileSystemLocation` object specifies the `identifier` , `location` , `mountOptions` , `mountPoint` , and `type` of a file system created using Amazon Elastic File System.
	FileSystemLocations interface{} `field:"optional" json:"fileSystemLocations" yaml:"fileSystemLocations"`
	// Information about logs for the build project.
	//
	// A project can create logs in CloudWatch Logs, an S3 bucket, or both.
	LogsConfig interface{} `field:"optional" json:"logsConfig" yaml:"logsConfig"`
	// The name of the build project.
	//
	// The name must be unique across all of the projects in your AWS account .
	Name *string `field:"optional" json:"name" yaml:"name"`
	// The number of minutes a build is allowed to be queued before it times out.
	QueuedTimeoutInMinutes *float64 `field:"optional" json:"queuedTimeoutInMinutes" yaml:"queuedTimeoutInMinutes"`
	// The ARN of the IAM role that enables CodeBuild to access the CloudWatch Logs and Amazon S3 artifacts for the project's builds.
	ResourceAccessRole *string `field:"optional" json:"resourceAccessRole" yaml:"resourceAccessRole"`
	// A list of `Artifacts` objects.
	//
	// Each artifacts object specifies output settings that the project generates during a build.
	SecondaryArtifacts interface{} `field:"optional" json:"secondaryArtifacts" yaml:"secondaryArtifacts"`
	// An array of `ProjectSource` objects.
	SecondarySources interface{} `field:"optional" json:"secondarySources" yaml:"secondarySources"`
	// An array of `ProjectSourceVersion` objects.
	//
	// If `secondarySourceVersions` is specified at the build level, then they take over these `secondarySourceVersions` (at the project level).
	SecondarySourceVersions interface{} `field:"optional" json:"secondarySourceVersions" yaml:"secondarySourceVersions"`
	// A version of the build input to be built for this project.
	//
	// If not specified, the latest version is used. If specified, it must be one of:
	//
	// - For CodeCommit: the commit ID, branch, or Git tag to use.
	// - For GitHub: the commit ID, pull request ID, branch name, or tag name that corresponds to the version of the source code you want to build. If a pull request ID is specified, it must use the format `pr/pull-request-ID` (for example `pr/25` ). If a branch name is specified, the branch's HEAD commit ID is used. If not specified, the default branch's HEAD commit ID is used.
	// - For Bitbucket: the commit ID, branch name, or tag name that corresponds to the version of the source code you want to build. If a branch name is specified, the branch's HEAD commit ID is used. If not specified, the default branch's HEAD commit ID is used.
	// - For Amazon S3: the version ID of the object that represents the build input ZIP file to use.
	//
	// If `sourceVersion` is specified at the build level, then that version takes precedence over this `sourceVersion` (at the project level).
	//
	// For more information, see [Source Version Sample with CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-source-version.html) in the *AWS CodeBuild User Guide* .
	SourceVersion *string `field:"optional" json:"sourceVersion" yaml:"sourceVersion"`
	// An arbitrary set of tags (key-value pairs) for the AWS CodeBuild project.
	//
	// These tags are available for use by AWS services that support AWS CodeBuild build project tags.
	Tags *[]*awscdk.CfnTag `field:"optional" json:"tags" yaml:"tags"`
	// How long, in minutes, from 5 to 480 (8 hours), for AWS CodeBuild to wait before timing out any related build that did not get marked as completed.
	//
	// The default is 60 minutes.
	TimeoutInMinutes *float64 `field:"optional" json:"timeoutInMinutes" yaml:"timeoutInMinutes"`
	// For an existing AWS CodeBuild build project that has its source code stored in a GitHub repository, enables AWS CodeBuild to begin automatically rebuilding the source code every time a code change is pushed to the repository.
	Triggers interface{} `field:"optional" json:"triggers" yaml:"triggers"`
	// Specifies the visibility of the project's builds. Possible values are:.
	//
	// - **PUBLIC_READ** - The project builds are visible to the public.
	// - **PRIVATE** - The project builds are not visible to the public.
	Visibility *string `field:"optional" json:"visibility" yaml:"visibility"`
	// `VpcConfig` specifies settings that enable AWS CodeBuild to access resources in an Amazon VPC.
	//
	// For more information, see [Use AWS CodeBuild with Amazon Virtual Private Cloud](https://docs.aws.amazon.com/codebuild/latest/userguide/vpc-support.html) in the *AWS CodeBuild User Guide* .
	VpcConfig interface{} `field:"optional" json:"vpcConfig" yaml:"vpcConfig"`
}

Properties for defining a `CfnProject`.

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"

cfnProjectProps := &cfnProjectProps{
	artifacts: &artifactsProperty{
		type: jsii.String("type"),

		// the properties below are optional
		artifactIdentifier: jsii.String("artifactIdentifier"),
		encryptionDisabled: jsii.Boolean(false),
		location: jsii.String("location"),
		name: jsii.String("name"),
		namespaceType: jsii.String("namespaceType"),
		overrideArtifactName: jsii.Boolean(false),
		packaging: jsii.String("packaging"),
		path: jsii.String("path"),
	},
	environment: &environmentProperty{
		computeType: jsii.String("computeType"),
		image: jsii.String("image"),
		type: jsii.String("type"),

		// the properties below are optional
		certificate: jsii.String("certificate"),
		environmentVariables: []interface{}{
			&environmentVariableProperty{
				name: jsii.String("name"),
				value: jsii.String("value"),

				// the properties below are optional
				type: jsii.String("type"),
			},
		},
		imagePullCredentialsType: jsii.String("imagePullCredentialsType"),
		privilegedMode: jsii.Boolean(false),
		registryCredential: &registryCredentialProperty{
			credential: jsii.String("credential"),
			credentialProvider: jsii.String("credentialProvider"),
		},
	},
	serviceRole: jsii.String("serviceRole"),
	source: &sourceProperty{
		type: jsii.String("type"),

		// the properties below are optional
		auth: &sourceAuthProperty{
			type: jsii.String("type"),

			// the properties below are optional
			resource: jsii.String("resource"),
		},
		buildSpec: jsii.String("buildSpec"),
		buildStatusConfig: &buildStatusConfigProperty{
			context: jsii.String("context"),
			targetUrl: jsii.String("targetUrl"),
		},
		gitCloneDepth: jsii.Number(123),
		gitSubmodulesConfig: &gitSubmodulesConfigProperty{
			fetchSubmodules: jsii.Boolean(false),
		},
		insecureSsl: jsii.Boolean(false),
		location: jsii.String("location"),
		reportBuildStatus: jsii.Boolean(false),
		sourceIdentifier: jsii.String("sourceIdentifier"),
	},

	// the properties below are optional
	badgeEnabled: jsii.Boolean(false),
	buildBatchConfig: &projectBuildBatchConfigProperty{
		batchReportMode: jsii.String("batchReportMode"),
		combineArtifacts: jsii.Boolean(false),
		restrictions: &batchRestrictionsProperty{
			computeTypesAllowed: []*string{
				jsii.String("computeTypesAllowed"),
			},
			maximumBuildsAllowed: jsii.Number(123),
		},
		serviceRole: jsii.String("serviceRole"),
		timeoutInMins: jsii.Number(123),
	},
	cache: &projectCacheProperty{
		type: jsii.String("type"),

		// the properties below are optional
		location: jsii.String("location"),
		modes: []*string{
			jsii.String("modes"),
		},
	},
	concurrentBuildLimit: jsii.Number(123),
	description: jsii.String("description"),
	encryptionKey: jsii.String("encryptionKey"),
	fileSystemLocations: []interface{}{
		&projectFileSystemLocationProperty{
			identifier: jsii.String("identifier"),
			location: jsii.String("location"),
			mountPoint: jsii.String("mountPoint"),
			type: jsii.String("type"),

			// the properties below are optional
			mountOptions: jsii.String("mountOptions"),
		},
	},
	logsConfig: &logsConfigProperty{
		cloudWatchLogs: &cloudWatchLogsConfigProperty{
			status: jsii.String("status"),

			// the properties below are optional
			groupName: jsii.String("groupName"),
			streamName: jsii.String("streamName"),
		},
		s3Logs: &s3LogsConfigProperty{
			status: jsii.String("status"),

			// the properties below are optional
			encryptionDisabled: jsii.Boolean(false),
			location: jsii.String("location"),
		},
	},
	name: jsii.String("name"),
	queuedTimeoutInMinutes: jsii.Number(123),
	resourceAccessRole: jsii.String("resourceAccessRole"),
	secondaryArtifacts: []interface{}{
		&artifactsProperty{
			type: jsii.String("type"),

			// the properties below are optional
			artifactIdentifier: jsii.String("artifactIdentifier"),
			encryptionDisabled: jsii.Boolean(false),
			location: jsii.String("location"),
			name: jsii.String("name"),
			namespaceType: jsii.String("namespaceType"),
			overrideArtifactName: jsii.Boolean(false),
			packaging: jsii.String("packaging"),
			path: jsii.String("path"),
		},
	},
	secondarySources: []interface{}{
		&sourceProperty{
			type: jsii.String("type"),

			// the properties below are optional
			auth: &sourceAuthProperty{
				type: jsii.String("type"),

				// the properties below are optional
				resource: jsii.String("resource"),
			},
			buildSpec: jsii.String("buildSpec"),
			buildStatusConfig: &buildStatusConfigProperty{
				context: jsii.String("context"),
				targetUrl: jsii.String("targetUrl"),
			},
			gitCloneDepth: jsii.Number(123),
			gitSubmodulesConfig: &gitSubmodulesConfigProperty{
				fetchSubmodules: jsii.Boolean(false),
			},
			insecureSsl: jsii.Boolean(false),
			location: jsii.String("location"),
			reportBuildStatus: jsii.Boolean(false),
			sourceIdentifier: jsii.String("sourceIdentifier"),
		},
	},
	secondarySourceVersions: []interface{}{
		&projectSourceVersionProperty{
			sourceIdentifier: jsii.String("sourceIdentifier"),

			// the properties below are optional
			sourceVersion: jsii.String("sourceVersion"),
		},
	},
	sourceVersion: jsii.String("sourceVersion"),
	tags: []cfnTag{
		&cfnTag{
			key: jsii.String("key"),
			value: jsii.String("value"),
		},
	},
	timeoutInMinutes: jsii.Number(123),
	triggers: &projectTriggersProperty{
		buildType: jsii.String("buildType"),
		filterGroups: []interface{}{
			[]interface{}{
				&webhookFilterProperty{
					pattern: jsii.String("pattern"),
					type: jsii.String("type"),

					// the properties below are optional
					excludeMatchedPattern: jsii.Boolean(false),
				},
			},
		},
		webhook: jsii.Boolean(false),
	},
	visibility: jsii.String("visibility"),
	vpcConfig: &vpcConfigProperty{
		securityGroupIds: []*string{
			jsii.String("securityGroupIds"),
		},
		subnets: []*string{
			jsii.String("subnets"),
		},
		vpcId: jsii.String("vpcId"),
	},
}

type CfnProject_ArtifactsProperty 

type CfnProject_ArtifactsProperty struct {
	// The type of build output artifact. Valid values include:.
	//
	// - `CODEPIPELINE` : The build project has build output generated through CodePipeline.
	//
	// > The `CODEPIPELINE` type is not supported for `secondaryArtifacts` .
	// - `NO_ARTIFACTS` : The build project does not produce any build output.
	// - `S3` : The build project stores build output in Amazon S3.
	Type *string `field:"required" json:"type" yaml:"type"`
	// An identifier for this artifact definition.
	ArtifactIdentifier *string `field:"optional" json:"artifactIdentifier" yaml:"artifactIdentifier"`
	// Set to true if you do not want your output artifacts encrypted.
	//
	// This option is valid only if your artifacts type is Amazon Simple Storage Service (Amazon S3). If this is set with another artifacts type, an `invalidInputException` is thrown.
	EncryptionDisabled interface{} `field:"optional" json:"encryptionDisabled" yaml:"encryptionDisabled"`
	// Information about the build output artifact location:.
	//
	// - If `type` is set to `CODEPIPELINE` , AWS CodePipeline ignores this value if specified. This is because CodePipeline manages its build output locations instead of CodeBuild .
	// - If `type` is set to `NO_ARTIFACTS` , this value is ignored if specified, because no build output is produced.
	// - If `type` is set to `S3` , this is the name of the output bucket.
	//
	// If you specify `CODEPIPELINE` or `NO_ARTIFACTS` for the `Type` property, don't specify this property. For all of the other types, you must specify this property.
	Location *string `field:"optional" json:"location" yaml:"location"`
	// Along with `path` and `namespaceType` , the pattern that AWS CodeBuild uses to name and store the output artifact:.
	//
	// - If `type` is set to `CODEPIPELINE` , AWS CodePipeline ignores this value if specified. This is because CodePipeline manages its build output names instead of AWS CodeBuild .
	// - If `type` is set to `NO_ARTIFACTS` , this value is ignored if specified, because no build output is produced.
	// - If `type` is set to `S3` , this is the name of the output artifact object. If you set the name to be a forward slash ("/"), the artifact is stored in the root of the output bucket.
	//
	// For example:
	//
	// - If `path` is set to `MyArtifacts` , `namespaceType` is set to `BUILD_ID` , and `name` is set to `MyArtifact.zip` , then the output artifact is stored in `MyArtifacts/ *build-ID* /MyArtifact.zip` .
	// - If `path` is empty, `namespaceType` is set to `NONE` , and `name` is set to " `/` ", the output artifact is stored in the root of the output bucket.
	// - If `path` is set to `MyArtifacts` , `namespaceType` is set to `BUILD_ID` , and `name` is set to " `/` ", the output artifact is stored in `MyArtifacts/ *build-ID*` .
	//
	// If you specify `CODEPIPELINE` or `NO_ARTIFACTS` for the `Type` property, don't specify this property. For all of the other types, you must specify this property.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// Along with `path` and `name` , the pattern that AWS CodeBuild uses to determine the name and location to store the output artifact:  - If `type` is set to `CODEPIPELINE` , CodePipeline ignores this value if specified.
	//
	// This is because CodePipeline manages its build output names instead of AWS CodeBuild .
	// - If `type` is set to `NO_ARTIFACTS` , this value is ignored if specified, because no build output is produced.
	// - If `type` is set to `S3` , valid values include:
	//
	// - `BUILD_ID` : Include the build ID in the location of the build output artifact.
	// - `NONE` : Do not include the build ID. This is the default if `namespaceType` is not specified.
	//
	// For example, if `path` is set to `MyArtifacts` , `namespaceType` is set to `BUILD_ID` , and `name` is set to `MyArtifact.zip` , the output artifact is stored in `MyArtifacts/<build-ID>/MyArtifact.zip` .
	NamespaceType *string `field:"optional" json:"namespaceType" yaml:"namespaceType"`
	// If set to true a name specified in the buildspec file overrides the artifact name.
	//
	// The name specified in a buildspec file is calculated at build time and uses the Shell command language. For example, you can append a date and time to your artifact name so that it is always unique.
	OverrideArtifactName interface{} `field:"optional" json:"overrideArtifactName" yaml:"overrideArtifactName"`
	// The type of build output artifact to create:.
	//
	// - If `type` is set to `CODEPIPELINE` , CodePipeline ignores this value if specified. This is because CodePipeline manages its build output artifacts instead of AWS CodeBuild .
	// - If `type` is set to `NO_ARTIFACTS` , this value is ignored if specified, because no build output is produced.
	// - If `type` is set to `S3` , valid values include:
	//
	// - `NONE` : AWS CodeBuild creates in the output bucket a folder that contains the build output. This is the default if `packaging` is not specified.
	// - `ZIP` : AWS CodeBuild creates in the output bucket a ZIP file that contains the build output.
	Packaging *string `field:"optional" json:"packaging" yaml:"packaging"`
	// Along with `namespaceType` and `name` , the pattern that AWS CodeBuild uses to name and store the output artifact:.
	//
	// - If `type` is set to `CODEPIPELINE` , CodePipeline ignores this value if specified. This is because CodePipeline manages its build output names instead of AWS CodeBuild .
	// - If `type` is set to `NO_ARTIFACTS` , this value is ignored if specified, because no build output is produced.
	// - If `type` is set to `S3` , this is the path to the output artifact. If `path` is not specified, `path` is not used.
	//
	// For example, if `path` is set to `MyArtifacts` , `namespaceType` is set to `NONE` , and `name` is set to `MyArtifact.zip` , the output artifact is stored in the output bucket at `MyArtifacts/MyArtifact.zip` .
	Path *string `field:"optional" json:"path" yaml:"path"`
}

`Artifacts` is a property of the [AWS::CodeBuild::Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that specifies output settings for artifacts generated by an AWS CodeBuild build.

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"

artifactsProperty := &artifactsProperty{
	type: jsii.String("type"),

	// the properties below are optional
	artifactIdentifier: jsii.String("artifactIdentifier"),
	encryptionDisabled: jsii.Boolean(false),
	location: jsii.String("location"),
	name: jsii.String("name"),
	namespaceType: jsii.String("namespaceType"),
	overrideArtifactName: jsii.Boolean(false),
	packaging: jsii.String("packaging"),
	path: jsii.String("path"),
}

type CfnProject_BatchRestrictionsProperty 

type CfnProject_BatchRestrictionsProperty struct {
	// An array of strings that specify the compute types that are allowed for the batch build.
	//
	// See [Build environment compute types](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html) in the *AWS CodeBuild User Guide* for these values.
	ComputeTypesAllowed *[]*string `field:"optional" json:"computeTypesAllowed" yaml:"computeTypesAllowed"`
	// Specifies the maximum number of builds allowed.
	MaximumBuildsAllowed *float64 `field:"optional" json:"maximumBuildsAllowed" yaml:"maximumBuildsAllowed"`
}

Specifies restrictions for the batch build.

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"

batchRestrictionsProperty := &batchRestrictionsProperty{
	computeTypesAllowed: []*string{
		jsii.String("computeTypesAllowed"),
	},
	maximumBuildsAllowed: jsii.Number(123),
}

type CfnProject_BuildStatusConfigProperty 

type CfnProject_BuildStatusConfigProperty struct {
	// Specifies the context of the build status CodeBuild sends to the source provider.
	//
	// The usage of this parameter depends on the source provider.
	//
	// - **Bitbucket** - This parameter is used for the `name` parameter in the Bitbucket commit status. For more information, see [build](https://docs.aws.amazon.com/https://developer.atlassian.com/bitbucket/api/2/reference/resource/repositories/%7Bworkspace%7D/%7Brepo_slug%7D/commit/%7Bnode%7D/statuses/build) in the Bitbucket API documentation.
	// - **GitHub/GitHub Enterprise Server** - This parameter is used for the `context` parameter in the GitHub commit status. For more information, see [Create a commit status](https://docs.aws.amazon.com/https://developer.github.com/v3/repos/statuses/#create-a-commit-status) in the GitHub developer guide.
	Context *string `field:"optional" json:"context" yaml:"context"`
	// Specifies the target url of the build status CodeBuild sends to the source provider.
	//
	// The usage of this parameter depends on the source provider.
	//
	// - **Bitbucket** - This parameter is used for the `url` parameter in the Bitbucket commit status. For more information, see [build](https://docs.aws.amazon.com/https://developer.atlassian.com/bitbucket/api/2/reference/resource/repositories/%7Bworkspace%7D/%7Brepo_slug%7D/commit/%7Bnode%7D/statuses/build) in the Bitbucket API documentation.
	// - **GitHub/GitHub Enterprise Server** - This parameter is used for the `target_url` parameter in the GitHub commit status. For more information, see [Create a commit status](https://docs.aws.amazon.com/https://developer.github.com/v3/repos/statuses/#create-a-commit-status) in the GitHub developer guide.
	TargetUrl *string `field:"optional" json:"targetUrl" yaml:"targetUrl"`
}

Contains information that defines how the AWS CodeBuild build project reports the build status to the source provider.

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"

buildStatusConfigProperty := &buildStatusConfigProperty{
	context: jsii.String("context"),
	targetUrl: jsii.String("targetUrl"),
}

type CfnProject_CloudWatchLogsConfigProperty 

type CfnProject_CloudWatchLogsConfigProperty struct {
	// The current status of the logs in CloudWatch Logs for a build project. Valid values are:.
	//
	// - `ENABLED` : CloudWatch Logs are enabled for this build project.
	// - `DISABLED` : CloudWatch Logs are not enabled for this build project.
	Status *string `field:"required" json:"status" yaml:"status"`
	// The group name of the logs in CloudWatch Logs.
	//
	// For more information, see [Working with Log Groups and Log Streams](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) .
	GroupName *string `field:"optional" json:"groupName" yaml:"groupName"`
	// The prefix of the stream name of the CloudWatch Logs.
	//
	// For more information, see [Working with Log Groups and Log Streams](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html) .
	StreamName *string `field:"optional" json:"streamName" yaml:"streamName"`
}

`CloudWatchLogs` is a property of the [AWS CodeBuild Project LogsConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-logsconfig.html) property type that specifies settings for CloudWatch logs generated by an AWS CodeBuild build.

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"

cloudWatchLogsConfigProperty := &cloudWatchLogsConfigProperty{
	status: jsii.String("status"),

	// the properties below are optional
	groupName: jsii.String("groupName"),
	streamName: jsii.String("streamName"),
}

type CfnProject_EnvironmentProperty 

type CfnProject_EnvironmentProperty struct {
	// The type of compute environment.
	//
	// This determines the number of CPU cores and memory the build environment uses. Available values include:
	//
	// - `BUILD_GENERAL1_SMALL` : Use up to 3 GB memory and 2 vCPUs for builds.
	// - `BUILD_GENERAL1_MEDIUM` : Use up to 7 GB memory and 4 vCPUs for builds.
	// - `BUILD_GENERAL1_LARGE` : Use up to 15 GB memory and 8 vCPUs for builds.
	//
	// For more information, see [Build Environment Compute Types](https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-compute-types.html) in the *AWS CodeBuild User Guide.*
	ComputeType *string `field:"required" json:"computeType" yaml:"computeType"`
	// The image tag or image digest that identifies the Docker image to use for this build project.
	//
	// Use the following formats:
	//
	// - For an image tag: `<registry>/<repository>:<tag>` . For example, in the Docker repository that CodeBuild uses to manage its Docker images, this would be `aws/codebuild/standard:4.0` .
	// - For an image digest: `<registry>/<repository>@<digest>` . For example, to specify an image with the digest "sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf," use `<registry>/<repository>@sha256:cbbf2f9a99b47fc460d422812b6a5adff7dfee951d8fa2e4a98caa0382cfbdbf` .
	//
	// For more information, see [Docker images provided by CodeBuild](https://docs.aws.amazon.com//codebuild/latest/userguide/build-env-ref-available.html) in the *AWS CodeBuild user guide* .
	Image *string `field:"required" json:"image" yaml:"image"`
	// The type of build environment to use for related builds.
	//
	// - The environment type `ARM_CONTAINER` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), EU (Ireland), Asia Pacific (Mumbai), Asia Pacific (Tokyo), Asia Pacific (Sydney), and EU (Frankfurt).
	// - The environment type `LINUX_CONTAINER` with compute type `build.general1.2xlarge` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Canada (Central), EU (Ireland), EU (London), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Seoul), Asia Pacific (Singapore), Asia Pacific (Sydney), China (Beijing), and China (Ningxia).
	// - The environment type `LINUX_GPU_CONTAINER` is available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), Canada (Central), EU (Ireland), EU (London), EU (Frankfurt), Asia Pacific (Tokyo), Asia Pacific (Seoul), Asia Pacific (Singapore), Asia Pacific (Sydney) , China (Beijing), and China (Ningxia).
	//
	// - The environment types `WINDOWS_CONTAINER` and `WINDOWS_SERVER_2019_CONTAINER` are available only in regions US East (N. Virginia), US East (Ohio), US West (Oregon), and EU (Ireland).
	//
	// For more information, see [Build environment compute types](https://docs.aws.amazon.com//codebuild/latest/userguide/build-env-ref-compute-types.html) in the *AWS CodeBuild user guide* .
	Type *string `field:"required" json:"type" yaml:"type"`
	// The ARN of the Amazon S3 bucket, path prefix, and object key that contains the PEM-encoded certificate for the build project.
	//
	// For more information, see [certificate](https://docs.aws.amazon.com/codebuild/latest/userguide/create-project-cli.html#cli.environment.certificate) in the *AWS CodeBuild User Guide* .
	Certificate *string `field:"optional" json:"certificate" yaml:"certificate"`
	// A set of environment variables to make available to builds for this build project.
	EnvironmentVariables interface{} `field:"optional" json:"environmentVariables" yaml:"environmentVariables"`
	// The type of credentials AWS CodeBuild uses to pull images in your build. There are two valid values:.
	//
	// - `CODEBUILD` specifies that AWS CodeBuild uses its own credentials. This requires that you modify your ECR repository policy to trust AWS CodeBuild service principal.
	// - `SERVICE_ROLE` specifies that AWS CodeBuild uses your build project's service role.
	//
	// When you use a cross-account or private registry image, you must use SERVICE_ROLE credentials. When you use an AWS CodeBuild curated image, you must use CODEBUILD credentials.
	ImagePullCredentialsType *string `field:"optional" json:"imagePullCredentialsType" yaml:"imagePullCredentialsType"`
	// Enables running the Docker daemon inside a Docker container.
	//
	// Set to true only if the build project is used to build Docker images. Otherwise, a build that attempts to interact with the Docker daemon fails. The default setting is `false` .
	//
	// You can initialize the Docker daemon during the install phase of your build by adding one of the following sets of commands to the install phase of your buildspec file:
	//
	// If the operating system's base image is Ubuntu Linux:
	//
	// `- nohup /usr/local/bin/dockerd --host=unix:///var/run/docker.sock --host=tcp://0.0.0.0:2375 --storage-driver=overlay&`
	//
	// `- timeout 15 sh -c "until docker info; do echo .; sleep 1; done"`
	//
	// If the operating system's base image is Alpine Linux and the previous command does not work, add the `-t` argument to `timeout` :
	//
	// `- nohup /usr/local/bin/dockerd --host=unix:///var/run/docker.sock --host=tcp://0.0.0.0:2375 --storage-driver=overlay&`
	//
	// `- timeout -t 15 sh -c "until docker info; do echo .; sleep 1; done"`
	PrivilegedMode interface{} `field:"optional" json:"privilegedMode" yaml:"privilegedMode"`
	// `RegistryCredential` is a property of the [AWS::CodeBuild::Project Environment](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html#cfn-codebuild-project-environment) property that specifies information about credentials that provide access to a private Docker registry. When this is set:.
	//
	// - `imagePullCredentialsType` must be set to `SERVICE_ROLE` .
	// - images cannot be curated or an Amazon ECR image.
	RegistryCredential interface{} `field:"optional" json:"registryCredential" yaml:"registryCredential"`
}

`Environment` is a property of the [AWS::CodeBuild::Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that specifies the environment for an AWS CodeBuild project.

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"

environmentProperty := &environmentProperty{
	computeType: jsii.String("computeType"),
	image: jsii.String("image"),
	type: jsii.String("type"),

	// the properties below are optional
	certificate: jsii.String("certificate"),
	environmentVariables: []interface{}{
		&environmentVariableProperty{
			name: jsii.String("name"),
			value: jsii.String("value"),

			// the properties below are optional
			type: jsii.String("type"),
		},
	},
	imagePullCredentialsType: jsii.String("imagePullCredentialsType"),
	privilegedMode: jsii.Boolean(false),
	registryCredential: &registryCredentialProperty{
		credential: jsii.String("credential"),
		credentialProvider: jsii.String("credentialProvider"),
	},
}

type CfnProject_EnvironmentVariableProperty 

type CfnProject_EnvironmentVariableProperty struct {
	// The name or key of the environment variable.
	Name *string `field:"required" json:"name" yaml:"name"`
	// The value of the environment variable.
	//
	// > We strongly discourage the use of `PLAINTEXT` environment variables to store sensitive values, especially AWS secret key IDs and secret access keys. `PLAINTEXT` environment variables can be displayed in plain text using the AWS CodeBuild console and the AWS CLI . For sensitive values, we recommend you use an environment variable of type `PARAMETER_STORE` or `SECRETS_MANAGER` .
	Value *string `field:"required" json:"value" yaml:"value"`
	// The type of environment variable. Valid values include:.
	//
	// - `PARAMETER_STORE` : An environment variable stored in Systems Manager Parameter Store. To learn how to specify a parameter store environment variable, see [env/parameter-store](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec.env.parameter-store) in the *AWS CodeBuild User Guide* .
	// - `PLAINTEXT` : An environment variable in plain text format. This is the default value.
	// - `SECRETS_MANAGER` : An environment variable stored in AWS Secrets Manager . To learn how to specify a secrets manager environment variable, see [env/secrets-manager](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec.env.secrets-manager) in the *AWS CodeBuild User Guide* .
	Type *string `field:"optional" json:"type" yaml:"type"`
}

`EnvironmentVariable` is a property of the [AWS CodeBuild Project Environment](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-environment.html) property type that specifies the name and value of an environment variable for an AWS CodeBuild project environment. When you use the environment to run a build, these variables are available for your builds to use. `EnvironmentVariable` contains a list of `EnvironmentVariable` property types.

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"

environmentVariableProperty := &environmentVariableProperty{
	name: jsii.String("name"),
	value: jsii.String("value"),

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

type CfnProject_GitSubmodulesConfigProperty 

type CfnProject_GitSubmodulesConfigProperty struct {
	// Set to true to fetch Git submodules for your AWS CodeBuild build project.
	FetchSubmodules interface{} `field:"required" json:"fetchSubmodules" yaml:"fetchSubmodules"`
}

`GitSubmodulesConfig` is a property of the [AWS CodeBuild Project Source](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-source.html) property type that specifies information about the Git submodules configuration for the build project.

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"

gitSubmodulesConfigProperty := &gitSubmodulesConfigProperty{
	fetchSubmodules: jsii.Boolean(false),
}

type CfnProject_LogsConfigProperty 

type CfnProject_LogsConfigProperty struct {
	// Information about CloudWatch Logs for a build project.
	//
	// CloudWatch Logs are enabled by default.
	CloudWatchLogs interface{} `field:"optional" json:"cloudWatchLogs" yaml:"cloudWatchLogs"`
	// Information about logs built to an S3 bucket for a build project.
	//
	// S3 logs are not enabled by default.
	S3Logs interface{} `field:"optional" json:"s3Logs" yaml:"s3Logs"`
}

`LogsConfig` is a property of the [AWS CodeBuild Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that specifies information about logs for a build project. These can be logs in Amazon CloudWatch Logs, built in a specified S3 bucket, or both.

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"

logsConfigProperty := &logsConfigProperty{
	cloudWatchLogs: &cloudWatchLogsConfigProperty{
		status: jsii.String("status"),

		// the properties below are optional
		groupName: jsii.String("groupName"),
		streamName: jsii.String("streamName"),
	},
	s3Logs: &s3LogsConfigProperty{
		status: jsii.String("status"),

		// the properties below are optional
		encryptionDisabled: jsii.Boolean(false),
		location: jsii.String("location"),
	},
}

type CfnProject_ProjectBuildBatchConfigProperty 

type CfnProject_ProjectBuildBatchConfigProperty struct {
	// Specifies how build status reports are sent to the source provider for the batch build.
	//
	// This property is only used when the source provider for your project is Bitbucket, GitHub, or GitHub Enterprise, and your project is configured to report build statuses to the source provider.
	//
	// - **REPORT_AGGREGATED_BATCH** - (Default) Aggregate all of the build statuses into a single status report.
	// - **REPORT_INDIVIDUAL_BUILDS** - Send a separate status report for each individual build.
	BatchReportMode *string `field:"optional" json:"batchReportMode" yaml:"batchReportMode"`
	// Specifies if the build artifacts for the batch build should be combined into a single artifact location.
	CombineArtifacts interface{} `field:"optional" json:"combineArtifacts" yaml:"combineArtifacts"`
	// A `BatchRestrictions` object that specifies the restrictions for the batch build.
	Restrictions interface{} `field:"optional" json:"restrictions" yaml:"restrictions"`
	// Specifies the service role ARN for the batch build project.
	ServiceRole *string `field:"optional" json:"serviceRole" yaml:"serviceRole"`
	// Specifies the maximum amount of time, in minutes, that the batch build must be completed in.
	TimeoutInMins *float64 `field:"optional" json:"timeoutInMins" yaml:"timeoutInMins"`
}

Contains configuration information about a batch build project.

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"

projectBuildBatchConfigProperty := &projectBuildBatchConfigProperty{
	batchReportMode: jsii.String("batchReportMode"),
	combineArtifacts: jsii.Boolean(false),
	restrictions: &batchRestrictionsProperty{
		computeTypesAllowed: []*string{
			jsii.String("computeTypesAllowed"),
		},
		maximumBuildsAllowed: jsii.Number(123),
	},
	serviceRole: jsii.String("serviceRole"),
	timeoutInMins: jsii.Number(123),
}

type CfnProject_ProjectCacheProperty 

type CfnProject_ProjectCacheProperty struct {
	// The type of cache used by the build project. Valid values include:.
	//
	// - `NO_CACHE` : The build project does not use any cache.
	// - `S3` : The build project reads and writes from and to S3.
	// - `LOCAL` : The build project stores a cache locally on a build host that is only available to that build host.
	Type *string `field:"required" json:"type" yaml:"type"`
	// Information about the cache location:.
	//
	// - `NO_CACHE` or `LOCAL` : This value is ignored.
	// - `S3` : This is the S3 bucket name/prefix.
	Location *string `field:"optional" json:"location" yaml:"location"`
	// An array of strings that specify the local cache modes.
	//
	// You can use one or more local cache modes at the same time. This is only used for `LOCAL` cache types.
	//
	// Possible values are:
	//
	// - **LOCAL_SOURCE_CACHE** - Caches Git metadata for primary and secondary sources. After the cache is created, subsequent builds pull only the change between commits. This mode is a good choice for projects with a clean working directory and a source that is a large Git repository. If you choose this option and your project does not use a Git repository (GitHub, GitHub Enterprise, or Bitbucket), the option is ignored.
	// - **LOCAL_DOCKER_LAYER_CACHE** - Caches existing Docker layers. This mode is a good choice for projects that build or pull large Docker images. It can prevent the performance issues caused by pulling large Docker images down from the network.
	//
	// > - You can use a Docker layer cache in the Linux environment only.
	// > - The `privileged` flag must be set so that your project has the required Docker permissions.
	// > - You should consider the security implications before you use a Docker layer cache.
	// - **LOCAL_CUSTOM_CACHE** - Caches directories you specify in the buildspec file. This mode is a good choice if your build scenario is not suited to one of the other three local cache modes. If you use a custom cache:
	//
	// - Only directories can be specified for caching. You cannot specify individual files.
	// - Symlinks are used to reference cached directories.
	// - Cached directories are linked to your build before it downloads its project sources. Cached items are overridden if a source item has the same name. Directories are specified using cache paths in the buildspec file.
	Modes *[]*string `field:"optional" json:"modes" yaml:"modes"`
}

`ProjectCache` is a property of the [AWS CodeBuild Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that specifies information about the cache for the build project. If `ProjectCache` is not specified, then both of its properties default to `NO_CACHE` .

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"

projectCacheProperty := &projectCacheProperty{
	type: jsii.String("type"),

	// the properties below are optional
	location: jsii.String("location"),
	modes: []*string{
		jsii.String("modes"),
	},
}

type CfnProject_ProjectFileSystemLocationProperty 

type CfnProject_ProjectFileSystemLocationProperty struct {
	// The name used to access a file system created by Amazon EFS.
	//
	// CodeBuild creates an environment variable by appending the `identifier` in all capital letters to `CODEBUILD_` . For example, if you specify `my_efs` for `identifier` , a new environment variable is create named `CODEBUILD_MY_EFS` .
	//
	// The `identifier` is used to mount your file system.
	Identifier *string `field:"required" json:"identifier" yaml:"identifier"`
	// A string that specifies the location of the file system created by Amazon EFS.
	//
	// Its format is `efs-dns-name:/directory-path` . You can find the DNS name of file system when you view it in the Amazon EFS console. The directory path is a path to a directory in the file system that CodeBuild mounts. For example, if the DNS name of a file system is `fs-abcd1234.efs.us-west-2.amazonaws.com` , and its mount directory is `my-efs-mount-directory` , then the `location` is `fs-abcd1234.efs.us-west-2.amazonaws.com:/my-efs-mount-directory` .
	//
	// The directory path in the format `efs-dns-name:/directory-path` is optional. If you do not specify a directory path, the location is only the DNS name and CodeBuild mounts the entire file system.
	Location *string `field:"required" json:"location" yaml:"location"`
	// The location in the container where you mount the file system.
	MountPoint *string `field:"required" json:"mountPoint" yaml:"mountPoint"`
	// The type of the file system.
	//
	// The one supported type is `EFS` .
	Type *string `field:"required" json:"type" yaml:"type"`
	// The mount options for a file system created by Amazon EFS.
	//
	// The default mount options used by CodeBuild are `nfsvers=4.1,rsize=1048576,wsize=1048576,hard,timeo=600,retrans=2` . For more information, see [Recommended NFS Mount Options](https://docs.aws.amazon.com/efs/latest/ug/mounting-fs-nfs-mount-settings.html) .
	MountOptions *string `field:"optional" json:"mountOptions" yaml:"mountOptions"`
}

Information about a file system created by Amazon Elastic File System (EFS).

For more information, see [What Is Amazon Elastic File System?](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.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"

projectFileSystemLocationProperty := &projectFileSystemLocationProperty{
	identifier: jsii.String("identifier"),
	location: jsii.String("location"),
	mountPoint: jsii.String("mountPoint"),
	type: jsii.String("type"),

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

type CfnProject_ProjectSourceVersionProperty 

type CfnProject_ProjectSourceVersionProperty struct {
	// An identifier for a source in the build project.
	//
	// The identifier can only contain alphanumeric characters and underscores, and must be less than 128 characters in length.
	SourceIdentifier *string `field:"required" json:"sourceIdentifier" yaml:"sourceIdentifier"`
	// The source version for the corresponding source identifier. If specified, must be one of:.
	//
	// - For CodeCommit: the commit ID, branch, or Git tag to use.
	// - For GitHub: the commit ID, pull request ID, branch name, or tag name that corresponds to the version of the source code you want to build. If a pull request ID is specified, it must use the format `pr/pull-request-ID` (for example, `pr/25` ). If a branch name is specified, the branch's HEAD commit ID is used. If not specified, the default branch's HEAD commit ID is used.
	// - For Bitbucket: the commit ID, branch name, or tag name that corresponds to the version of the source code you want to build. If a branch name is specified, the branch's HEAD commit ID is used. If not specified, the default branch's HEAD commit ID is used.
	// - For Amazon S3: the version ID of the object that represents the build input ZIP file to use.
	//
	// For more information, see [Source Version Sample with CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-source-version.html) in the *AWS CodeBuild User Guide* .
	SourceVersion *string `field:"optional" json:"sourceVersion" yaml:"sourceVersion"`
}

A source identifier and its corresponding version.

Example: 

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

projectSourceVersionProperty := &projectSourceVersionProperty{
	sourceIdentifier: jsii.String("sourceIdentifier"),

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

type CfnProject_ProjectTriggersProperty 

type CfnProject_ProjectTriggersProperty struct {
	// Specifies the type of build this webhook will trigger. Allowed values are:.
	//
	// - **BUILD** - A single build
	// - **BUILD_BATCH** - A batch build.
	BuildType *string `field:"optional" json:"buildType" yaml:"buildType"`
	// A list of lists of `WebhookFilter` objects used to determine which webhook events are triggered.
	//
	// At least one `WebhookFilter` in the array must specify `EVENT` as its type.
	FilterGroups interface{} `field:"optional" json:"filterGroups" yaml:"filterGroups"`
	// Specifies whether or not to begin automatically rebuilding the source code every time a code change is pushed to the repository.
	Webhook interface{} `field:"optional" json:"webhook" yaml:"webhook"`
}

`ProjectTriggers` is a property of the [AWS CodeBuild Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that specifies webhooks that trigger an AWS CodeBuild build.

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"

projectTriggersProperty := &projectTriggersProperty{
	buildType: jsii.String("buildType"),
	filterGroups: []interface{}{
		[]interface{}{
			&webhookFilterProperty{
				pattern: jsii.String("pattern"),
				type: jsii.String("type"),

				// the properties below are optional
				excludeMatchedPattern: jsii.Boolean(false),
			},
		},
	},
	webhook: jsii.Boolean(false),
}

type CfnProject_RegistryCredentialProperty 

type CfnProject_RegistryCredentialProperty struct {
	// The Amazon Resource Name (ARN) or name of credentials created using AWS Secrets Manager .
	//
	// > The `credential` can use the name of the credentials only if they exist in your current AWS Region .
	Credential *string `field:"required" json:"credential" yaml:"credential"`
	// The service that created the credentials to access a private Docker registry.
	//
	// The valid value, SECRETS_MANAGER, is for AWS Secrets Manager .
	CredentialProvider *string `field:"required" json:"credentialProvider" yaml:"credentialProvider"`
}

`RegistryCredential` is a property of the [AWS CodeBuild Project Environment](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-environment.html) property type that specifies information about credentials that provide access to a private Docker registry. When this is set:.

- `imagePullCredentialsType` must be set to `SERVICE_ROLE` . - images cannot be curated or an Amazon ECR image.

For more information, see [Private Registry with AWS Secrets Manager Sample for AWS CodeBuild](https://docs.aws.amazon.com/codebuild/latest/userguide/sample-private-registry.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"

registryCredentialProperty := &registryCredentialProperty{
	credential: jsii.String("credential"),
	credentialProvider: jsii.String("credentialProvider"),
}

type CfnProject_S3LogsConfigProperty 

type CfnProject_S3LogsConfigProperty struct {
	// The current status of the S3 build logs. Valid values are:.
	//
	// - `ENABLED` : S3 build logs are enabled for this build project.
	// - `DISABLED` : S3 build logs are not enabled for this build project.
	Status *string `field:"required" json:"status" yaml:"status"`
	// Set to true if you do not want your S3 build log output encrypted.
	//
	// By default S3 build logs are encrypted.
	EncryptionDisabled interface{} `field:"optional" json:"encryptionDisabled" yaml:"encryptionDisabled"`
	// The ARN of an S3 bucket and the path prefix for S3 logs.
	//
	// If your Amazon S3 bucket name is `my-bucket` , and your path prefix is `build-log` , then acceptable formats are `my-bucket/build-log` or `arn:aws:s3:::my-bucket/build-log` .
	Location *string `field:"optional" json:"location" yaml:"location"`
}

`S3Logs` is a property of the [AWS CodeBuild Project LogsConfig](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-logsconfig.html) property type that specifies settings for logs generated by an AWS CodeBuild build in an S3 bucket.

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"

s3LogsConfigProperty := &s3LogsConfigProperty{
	status: jsii.String("status"),

	// the properties below are optional
	encryptionDisabled: jsii.Boolean(false),
	location: jsii.String("location"),
}

type CfnProject_SourceAuthProperty 

type CfnProject_SourceAuthProperty struct {
	// The authorization type to use. The only valid value is `OAUTH` , which represents the OAuth authorization type.
	//
	// > This data type is used by the AWS CodeBuild console only.
	Type *string `field:"required" json:"type" yaml:"type"`
	// The resource value that applies to the specified authorization type.
	//
	// > This data type is used by the AWS CodeBuild console only.
	Resource *string `field:"optional" json:"resource" yaml:"resource"`
}

`SourceAuth` is a property of the [AWS CodeBuild Project Source](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-source.html) property type that specifies authorization settings for AWS CodeBuild to access the source code to be built.

`SourceAuth` is for use by the CodeBuild console only. Do not get or set it directly.

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"

sourceAuthProperty := &sourceAuthProperty{
	type: jsii.String("type"),

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

type CfnProject_SourceProperty 

type CfnProject_SourceProperty struct {
	// The type of repository that contains the source code to be built. Valid values include:.
	//
	// - `BITBUCKET` : The source code is in a Bitbucket repository.
	// - `CODECOMMIT` : The source code is in an CodeCommit repository.
	// - `CODEPIPELINE` : The source code settings are specified in the source action of a pipeline in CodePipeline.
	// - `GITHUB` : The source code is in a GitHub or GitHub Enterprise Cloud repository.
	// - `GITHUB_ENTERPRISE` : The source code is in a GitHub Enterprise Server repository.
	// - `NO_SOURCE` : The project does not have input source code.
	// - `S3` : The source code is in an Amazon S3 bucket.
	Type *string `field:"required" json:"type" yaml:"type"`
	// Information about the authorization settings for AWS CodeBuild to access the source code to be built.
	//
	// This information is for the AWS CodeBuild console's use only. Your code should not get or set `Auth` directly.
	Auth interface{} `field:"optional" json:"auth" yaml:"auth"`
	// The build specification for the project.
	//
	// If this value is not provided, then the source code must contain a buildspec file named `buildspec.yml` at the root level. If this value is provided, it can be either a single string containing the entire build specification, or the path to an alternate buildspec file relative to the value of the built-in environment variable `CODEBUILD_SRC_DIR` . The alternate buildspec file can have a name other than `buildspec.yml` , for example `myspec.yml` or `build_spec_qa.yml` or similar. For more information, see the [Build Spec Reference](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-example) in the *AWS CodeBuild User Guide* .
	BuildSpec *string `field:"optional" json:"buildSpec" yaml:"buildSpec"`
	// Contains information that defines how the build project reports the build status to the source provider.
	//
	// This option is only used when the source provider is `GITHUB` , `GITHUB_ENTERPRISE` , or `BITBUCKET` .
	BuildStatusConfig interface{} `field:"optional" json:"buildStatusConfig" yaml:"buildStatusConfig"`
	// The depth of history to download.
	//
	// Minimum value is 0. If this value is 0, greater than 25, or not provided, then the full history is downloaded with each build project. If your source type is Amazon S3, this value is not supported.
	GitCloneDepth *float64 `field:"optional" json:"gitCloneDepth" yaml:"gitCloneDepth"`
	// Information about the Git submodules configuration for the build project.
	GitSubmodulesConfig interface{} `field:"optional" json:"gitSubmodulesConfig" yaml:"gitSubmodulesConfig"`
	// This is used with GitHub Enterprise only.
	//
	// Set to true to ignore SSL warnings while connecting to your GitHub Enterprise project repository. The default value is `false` . `InsecureSsl` should be used for testing purposes only. It should not be used in a production environment.
	InsecureSsl interface{} `field:"optional" json:"insecureSsl" yaml:"insecureSsl"`
	// Information about the location of the source code to be built. Valid values include:.
	//
	// - For source code settings that are specified in the source action of a pipeline in CodePipeline, `location` should not be specified. If it is specified, CodePipeline ignores it. This is because CodePipeline uses the settings in a pipeline's source action instead of this value.
	// - For source code in an CodeCommit repository, the HTTPS clone URL to the repository that contains the source code and the buildspec file (for example, `https://git-codecommit.<region-ID>.amazonaws.com/v1/repos/<repo-name>` ).
	// - For source code in an Amazon S3 input bucket, one of the following.
	//
	// - The path to the ZIP file that contains the source code (for example, `<bucket-name>/<path>/<object-name>.zip` ).
	// - The path to the folder that contains the source code (for example, `<bucket-name>/<path-to-source-code>/<folder>/` ).
	// - For source code in a GitHub repository, the HTTPS clone URL to the repository that contains the source and the buildspec file. You must connect your AWS account to your GitHub account. Use the AWS CodeBuild console to start creating a build project. When you use the console to connect (or reconnect) with GitHub, on the GitHub *Authorize application* page, for *Organization access* , choose *Request access* next to each repository you want to allow AWS CodeBuild to have access to, and then choose *Authorize application* . (After you have connected to your GitHub account, you do not need to finish creating the build project. You can leave the AWS CodeBuild console.) To instruct AWS CodeBuild to use this connection, in the `source` object, set the `auth` object's `type` value to `OAUTH` .
	// - For source code in a Bitbucket repository, the HTTPS clone URL to the repository that contains the source and the buildspec file. You must connect your AWS account to your Bitbucket account. Use the AWS CodeBuild console to start creating a build project. When you use the console to connect (or reconnect) with Bitbucket, on the Bitbucket *Confirm access to your account* page, choose *Grant access* . (After you have connected to your Bitbucket account, you do not need to finish creating the build project. You can leave the AWS CodeBuild console.) To instruct AWS CodeBuild to use this connection, in the `source` object, set the `auth` object's `type` value to `OAUTH` .
	//
	// If you specify `CODEPIPELINE` for the `Type` property, don't specify this property. For all of the other types, you must specify `Location` .
	Location *string `field:"optional" json:"location" yaml:"location"`
	// Set to true to report the status of a build's start and finish to your source provider.
	//
	// This option is valid only when your source provider is GitHub, GitHub Enterprise, or Bitbucket. If this is set and you use a different source provider, an `invalidInputException` is thrown.
	ReportBuildStatus interface{} `field:"optional" json:"reportBuildStatus" yaml:"reportBuildStatus"`
	// An identifier for this project source.
	//
	// The identifier can only contain alphanumeric characters and underscores, and must be less than 128 characters in length.
	SourceIdentifier *string `field:"optional" json:"sourceIdentifier" yaml:"sourceIdentifier"`
}

`Source` is a property of the [AWS::CodeBuild::Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that specifies the source code settings for the project, such as the source code's repository type and location.

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"

sourceProperty := &sourceProperty{
	type: jsii.String("type"),

	// the properties below are optional
	auth: &sourceAuthProperty{
		type: jsii.String("type"),

		// the properties below are optional
		resource: jsii.String("resource"),
	},
	buildSpec: jsii.String("buildSpec"),
	buildStatusConfig: &buildStatusConfigProperty{
		context: jsii.String("context"),
		targetUrl: jsii.String("targetUrl"),
	},
	gitCloneDepth: jsii.Number(123),
	gitSubmodulesConfig: &gitSubmodulesConfigProperty{
		fetchSubmodules: jsii.Boolean(false),
	},
	insecureSsl: jsii.Boolean(false),
	location: jsii.String("location"),
	reportBuildStatus: jsii.Boolean(false),
	sourceIdentifier: jsii.String("sourceIdentifier"),
}

type CfnProject_VpcConfigProperty 

type CfnProject_VpcConfigProperty struct {
	// A list of one or more security groups IDs in your Amazon VPC.
	//
	// The maximum count is 5.
	SecurityGroupIds *[]*string `field:"optional" json:"securityGroupIds" yaml:"securityGroupIds"`
	// A list of one or more subnet IDs in your Amazon VPC.
	//
	// The maximum count is 16.
	Subnets *[]*string `field:"optional" json:"subnets" yaml:"subnets"`
	// The ID of the Amazon VPC.
	VpcId *string `field:"optional" json:"vpcId" yaml:"vpcId"`
}

`VpcConfig` is a property of the [AWS::CodeBuild::Project](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html) resource that enable AWS CodeBuild to access resources in an Amazon VPC. For more information, see [Use AWS CodeBuild with Amazon Virtual Private Cloud](https://docs.aws.amazon.com/codebuild/latest/userguide/vpc-support.html) in the *AWS CodeBuild 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"

vpcConfigProperty := &vpcConfigProperty{
	securityGroupIds: []*string{
		jsii.String("securityGroupIds"),
	},
	subnets: []*string{
		jsii.String("subnets"),
	},
	vpcId: jsii.String("vpcId"),
}

type CfnProject_WebhookFilterProperty 

type CfnProject_WebhookFilterProperty struct {
	// For a `WebHookFilter` that uses `EVENT` type, a comma-separated string that specifies one or more events.
	//
	// For example, the webhook filter `PUSH, PULL_REQUEST_CREATED, PULL_REQUEST_UPDATED` allows all push, pull request created, and pull request updated events to trigger a build.
	//
	// For a `WebHookFilter` that uses any of the other filter types, a regular expression pattern. For example, a `WebHookFilter` that uses `HEAD_REF` for its `type` and the pattern `^refs/heads/` triggers a build when the head reference is a branch with a reference name `refs/heads/branch-name` .
	Pattern *string `field:"required" json:"pattern" yaml:"pattern"`
	// The type of webhook filter.
	//
	// There are six webhook filter types: `EVENT` , `ACTOR_ACCOUNT_ID` , `HEAD_REF` , `BASE_REF` , `FILE_PATH` , and `COMMIT_MESSAGE` .
	//
	// - **EVENT** - A webhook event triggers a build when the provided `pattern` matches one of five event types: `PUSH` , `PULL_REQUEST_CREATED` , `PULL_REQUEST_UPDATED` , `PULL_REQUEST_REOPENED` , and `PULL_REQUEST_MERGED` . The `EVENT` patterns are specified as a comma-separated string. For example, `PUSH, PULL_REQUEST_CREATED, PULL_REQUEST_UPDATED` filters all push, pull request created, and pull request updated events.
	//
	// > The `PULL_REQUEST_REOPENED` works with GitHub and GitHub Enterprise only.
	// - **ACTOR_ACCOUNT_ID** - A webhook event triggers a build when a GitHub, GitHub Enterprise, or Bitbucket account ID matches the regular expression `pattern` .
	// - **HEAD_REF** - A webhook event triggers a build when the head reference matches the regular expression `pattern` . For example, `refs/heads/branch-name` and `refs/tags/tag-name` .
	//
	// Works with GitHub and GitHub Enterprise push, GitHub and GitHub Enterprise pull request, Bitbucket push, and Bitbucket pull request events.
	// - **BASE_REF** - A webhook event triggers a build when the base reference matches the regular expression `pattern` . For example, `refs/heads/branch-name` .
	//
	// > Works with pull request events only.
	// - **FILE_PATH** - A webhook triggers a build when the path of a changed file matches the regular expression `pattern` .
	//
	// > Works with GitHub and Bitbucket events push and pull requests events. Also works with GitHub Enterprise push events, but does not work with GitHub Enterprise pull request events.
	// - **COMMIT_MESSAGE** - A webhook triggers a build when the head commit message matches the regular expression `pattern` .
	//
	// > Works with GitHub and Bitbucket events push and pull requests events. Also works with GitHub Enterprise push events, but does not work with GitHub Enterprise pull request events.
	Type *string `field:"required" json:"type" yaml:"type"`
	// Used to indicate that the `pattern` determines which webhook events do not trigger a build.
	//
	// If true, then a webhook event that does not match the `pattern` triggers a build. If false, then a webhook event that matches the `pattern` triggers a build.
	ExcludeMatchedPattern interface{} `field:"optional" json:"excludeMatchedPattern" yaml:"excludeMatchedPattern"`
}

`WebhookFilter` is a structure of the `FilterGroups` property on the [AWS CodeBuild Project ProjectTriggers](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-projecttriggers.html) property type that specifies which webhooks trigger an AWS CodeBuild build.

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"

webhookFilterProperty := &webhookFilterProperty{
	pattern: jsii.String("pattern"),
	type: jsii.String("type"),

	// the properties below are optional
	excludeMatchedPattern: jsii.Boolean(false),
}

type CfnReportGroup 

type CfnReportGroup interface {
	awscdk.CfnResource
	awscdk.IInspectable
	// The ARN of the AWS CodeBuild report group, such as `arn:aws:codebuild:region:123456789012:report-group/myReportGroupName` .
	AttrArn() *string
	// Options for this resource, such as condition, update policy etc.
	// Experimental.
	CfnOptions() awscdk.ICfnResourceOptions
	CfnProperties() *map[string]interface{}
	// AWS resource type.
	// Experimental.
	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.
	// Experimental.
	CreationStack() *[]*string
	// When deleting a report group, specifies if reports within the report group should be deleted.
	//
	// - **true** - Deletes any reports that belong to the report group before deleting the report group.
	// - **false** - You must delete any reports in the report group. This is the default value. If you delete a report group that contains one or more reports, an exception is thrown.
	DeleteReports() interface{}
	SetDeleteReports(val interface{})
	// Information about the destination where the raw data of this `ReportGroup` is exported.
	ExportConfig() interface{}
	SetExportConfig(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.
	// Experimental.
	LogicalId() *string
	// The name of the `ReportGroup` .
	Name() *string
	SetName(val *string)
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// 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 })`.
	// Experimental.
	Ref() *string
	// The stack in which this element is defined.
	//
	// CfnElements must be defined within a stack scope (directly or indirectly).
	// Experimental.
	Stack() awscdk.Stack
	// A list of tag key and value pairs associated with this report group.
	//
	// These tags are available for use by AWS services that support AWS CodeBuild report group tags.
	Tags() awscdk.TagManager
	// The type of the `ReportGroup` . This can be one of the following values:.
	//
	// - **CODE_COVERAGE** - The report group contains code coverage reports.
	// - **TEST** - The report group contains test reports.
	Type() *string
	SetType(val *string)
	// Return properties modified after initiation.
	//
	// Resources that expose mutable properties should override this function to
	// collect and return the properties object for this resource.
	// Experimental.
	UpdatedProperites() *map[string]interface{}
	// Syntactic sugar for `addOverride(path, undefined)`.
	// Experimental.
	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.
	// Experimental.
	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.
	//
	// Experimental.
	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.
	// Experimental.
	AddOverride(path *string, value interface{})
	// Adds an override that deletes the value of a property from the resource definition.
	// Experimental.
	AddPropertyDeletionOverride(propertyPath *string)
	// Adds an override to a resource property.
	//
	// Syntactic sugar for `addOverride("Properties.<...>", value)`.
	// Experimental.
	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`).
	// Experimental.
	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.
	// Experimental.
	GetAtt(attributeName *string) 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.
	//
	// Experimental.
	GetMetadata(key *string) interface{}
	// Examines the CloudFormation resource and discloses attributes.
	Inspect(inspector awscdk.TreeInspector)
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Overrides the auto-generated logical ID with a specific ID.
	// Experimental.
	OverrideLogicalId(newLogicalId *string)
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	RenderProperties(props *map[string]interface{}) *map[string]interface{}
	// 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.
	// Experimental.
	ShouldSynthesize() *bool
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	//
	// Returns: a string representation of this resource.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	Validate() *[]*string
	// Experimental.
	ValidateProperties(_properties interface{})
}

A CloudFormation `AWS::CodeBuild::ReportGroup`.

Represents a report group. A report group contains a collection of reports.

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"

cfnReportGroup := awscdk.Aws_codebuild.NewCfnReportGroup(this, jsii.String("MyCfnReportGroup"), &cfnReportGroupProps{
	exportConfig: &reportExportConfigProperty{
		exportConfigType: jsii.String("exportConfigType"),

		// the properties below are optional
		s3Destination: &s3ReportExportConfigProperty{
			bucket: jsii.String("bucket"),

			// the properties below are optional
			bucketOwner: jsii.String("bucketOwner"),
			encryptionDisabled: jsii.Boolean(false),
			encryptionKey: jsii.String("encryptionKey"),
			packaging: jsii.String("packaging"),
			path: jsii.String("path"),
		},
	},
	type: jsii.String("type"),

	// the properties below are optional
	deleteReports: jsii.Boolean(false),
	name: jsii.String("name"),
	tags: []cfnTag{
		&cfnTag{
			key: jsii.String("key"),
			value: jsii.String("value"),
		},
	},
})

func NewCfnReportGroup 

func NewCfnReportGroup(scope awscdk.Construct, id *string, props *CfnReportGroupProps) CfnReportGroup

Create a new `AWS::CodeBuild::ReportGroup`.

type CfnReportGroupProps 

type CfnReportGroupProps struct {
	// Information about the destination where the raw data of this `ReportGroup` is exported.
	ExportConfig interface{} `field:"required" json:"exportConfig" yaml:"exportConfig"`
	// The type of the `ReportGroup` . This can be one of the following values:.
	//
	// - **CODE_COVERAGE** - The report group contains code coverage reports.
	// - **TEST** - The report group contains test reports.
	Type *string `field:"required" json:"type" yaml:"type"`
	// When deleting a report group, specifies if reports within the report group should be deleted.
	//
	// - **true** - Deletes any reports that belong to the report group before deleting the report group.
	// - **false** - You must delete any reports in the report group. This is the default value. If you delete a report group that contains one or more reports, an exception is thrown.
	DeleteReports interface{} `field:"optional" json:"deleteReports" yaml:"deleteReports"`
	// The name of the `ReportGroup` .
	Name *string `field:"optional" json:"name" yaml:"name"`
	// A list of tag key and value pairs associated with this report group.
	//
	// These tags are available for use by AWS services that support AWS CodeBuild report group tags.
	Tags *[]*awscdk.CfnTag `field:"optional" json:"tags" yaml:"tags"`
}

Properties for defining a `CfnReportGroup`.

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"

cfnReportGroupProps := &cfnReportGroupProps{
	exportConfig: &reportExportConfigProperty{
		exportConfigType: jsii.String("exportConfigType"),

		// the properties below are optional
		s3Destination: &s3ReportExportConfigProperty{
			bucket: jsii.String("bucket"),

			// the properties below are optional
			bucketOwner: jsii.String("bucketOwner"),
			encryptionDisabled: jsii.Boolean(false),
			encryptionKey: jsii.String("encryptionKey"),
			packaging: jsii.String("packaging"),
			path: jsii.String("path"),
		},
	},
	type: jsii.String("type"),

	// the properties below are optional
	deleteReports: jsii.Boolean(false),
	name: jsii.String("name"),
	tags: []cfnTag{
		&cfnTag{
			key: jsii.String("key"),
			value: jsii.String("value"),
		},
	},
}

type CfnReportGroup_ReportExportConfigProperty 

type CfnReportGroup_ReportExportConfigProperty struct {
	// The export configuration type. Valid values are:.
	//
	// - `S3` : The report results are exported to an S3 bucket.
	// - `NO_EXPORT` : The report results are not exported.
	ExportConfigType *string `field:"required" json:"exportConfigType" yaml:"exportConfigType"`
	// A `S3ReportExportConfig` object that contains information about the S3 bucket where the run of a report is exported.
	S3Destination interface{} `field:"optional" json:"s3Destination" yaml:"s3Destination"`
}

Information about the location where the run of a report is exported.

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"

reportExportConfigProperty := &reportExportConfigProperty{
	exportConfigType: jsii.String("exportConfigType"),

	// the properties below are optional
	s3Destination: &s3ReportExportConfigProperty{
		bucket: jsii.String("bucket"),

		// the properties below are optional
		bucketOwner: jsii.String("bucketOwner"),
		encryptionDisabled: jsii.Boolean(false),
		encryptionKey: jsii.String("encryptionKey"),
		packaging: jsii.String("packaging"),
		path: jsii.String("path"),
	},
}

type CfnReportGroup_S3ReportExportConfigProperty 

type CfnReportGroup_S3ReportExportConfigProperty struct {
	// The name of the S3 bucket where the raw data of a report are exported.
	Bucket *string `field:"required" json:"bucket" yaml:"bucket"`
	// The AWS account identifier of the owner of the Amazon S3 bucket.
	//
	// This allows report data to be exported to an Amazon S3 bucket that is owned by an account other than the account running the build.
	BucketOwner *string `field:"optional" json:"bucketOwner" yaml:"bucketOwner"`
	// A boolean value that specifies if the results of a report are encrypted.
	EncryptionDisabled interface{} `field:"optional" json:"encryptionDisabled" yaml:"encryptionDisabled"`
	// The encryption key for the report's encrypted raw data.
	EncryptionKey *string `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	// The type of build output artifact to create. Valid values include:.
	//
	// - `NONE` : CodeBuild creates the raw data in the output bucket. This is the default if packaging is not specified.
	// - `ZIP` : CodeBuild creates a ZIP file with the raw data in the output bucket.
	Packaging *string `field:"optional" json:"packaging" yaml:"packaging"`
	// The path to the exported report's raw data results.
	Path *string `field:"optional" json:"path" yaml:"path"`
}

Information about the S3 bucket where the raw data of a report are exported.

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"

s3ReportExportConfigProperty := &s3ReportExportConfigProperty{
	bucket: jsii.String("bucket"),

	// the properties below are optional
	bucketOwner: jsii.String("bucketOwner"),
	encryptionDisabled: jsii.Boolean(false),
	encryptionKey: jsii.String("encryptionKey"),
	packaging: jsii.String("packaging"),
	path: jsii.String("path"),
}

type CfnSourceCredential 

type CfnSourceCredential interface {
	awscdk.CfnResource
	awscdk.IInspectable
	// The type of authentication used by the credentials.
	//
	// Valid options are OAUTH, BASIC_AUTH, or PERSONAL_ACCESS_TOKEN.
	AuthType() *string
	SetAuthType(val *string)
	// Options for this resource, such as condition, update policy etc.
	// Experimental.
	CfnOptions() awscdk.ICfnResourceOptions
	CfnProperties() *map[string]interface{}
	// AWS resource type.
	// Experimental.
	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.
	// Experimental.
	CreationStack() *[]*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.
	// Experimental.
	LogicalId() *string
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// 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 })`.
	// Experimental.
	Ref() *string
	// The type of source provider.
	//
	// The valid options are GITHUB, GITHUB_ENTERPRISE, or BITBUCKET.
	ServerType() *string
	SetServerType(val *string)
	// The stack in which this element is defined.
	//
	// CfnElements must be defined within a stack scope (directly or indirectly).
	// Experimental.
	Stack() awscdk.Stack
	// For GitHub or GitHub Enterprise, this is the personal access token.
	//
	// For Bitbucket, this is the app password.
	Token() *string
	SetToken(val *string)
	// Return properties modified after initiation.
	//
	// Resources that expose mutable properties should override this function to
	// collect and return the properties object for this resource.
	// Experimental.
	UpdatedProperites() *map[string]interface{}
	// The Bitbucket username when the `authType` is BASIC_AUTH.
	//
	// This parameter is not valid for other types of source providers or connections.
	Username() *string
	SetUsername(val *string)
	// Syntactic sugar for `addOverride(path, undefined)`.
	// Experimental.
	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.
	// Experimental.
	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.
	//
	// Experimental.
	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.
	// Experimental.
	AddOverride(path *string, value interface{})
	// Adds an override that deletes the value of a property from the resource definition.
	// Experimental.
	AddPropertyDeletionOverride(propertyPath *string)
	// Adds an override to a resource property.
	//
	// Syntactic sugar for `addOverride("Properties.<...>", value)`.
	// Experimental.
	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`).
	// Experimental.
	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.
	// Experimental.
	GetAtt(attributeName *string) 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.
	//
	// Experimental.
	GetMetadata(key *string) interface{}
	// Examines the CloudFormation resource and discloses attributes.
	Inspect(inspector awscdk.TreeInspector)
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Overrides the auto-generated logical ID with a specific ID.
	// Experimental.
	OverrideLogicalId(newLogicalId *string)
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	RenderProperties(props *map[string]interface{}) *map[string]interface{}
	// 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.
	// Experimental.
	ShouldSynthesize() *bool
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	//
	// Returns: a string representation of this resource.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	Validate() *[]*string
	// Experimental.
	ValidateProperties(_properties interface{})
}

A CloudFormation `AWS::CodeBuild::SourceCredential`.

Information about the credentials for a GitHub, GitHub Enterprise, or Bitbucket repository. We strongly recommend that you use AWS Secrets Manager to store your credentials. If you use Secrets Manager , you must have secrets in your 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) .

> For security purposes, do not use plain text 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"

cfnSourceCredential := awscdk.Aws_codebuild.NewCfnSourceCredential(this, jsii.String("MyCfnSourceCredential"), &cfnSourceCredentialProps{
	authType: jsii.String("authType"),
	serverType: jsii.String("serverType"),
	token: jsii.String("token"),

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

func NewCfnSourceCredential 

func NewCfnSourceCredential(scope awscdk.Construct, id *string, props *CfnSourceCredentialProps) CfnSourceCredential

Create a new `AWS::CodeBuild::SourceCredential`.

type CfnSourceCredentialProps 

type CfnSourceCredentialProps struct {
	// The type of authentication used by the credentials.
	//
	// Valid options are OAUTH, BASIC_AUTH, or PERSONAL_ACCESS_TOKEN.
	AuthType *string `field:"required" json:"authType" yaml:"authType"`
	// The type of source provider.
	//
	// The valid options are GITHUB, GITHUB_ENTERPRISE, or BITBUCKET.
	ServerType *string `field:"required" json:"serverType" yaml:"serverType"`
	// For GitHub or GitHub Enterprise, this is the personal access token.
	//
	// For Bitbucket, this is the app password.
	Token *string `field:"required" json:"token" yaml:"token"`
	// The Bitbucket username when the `authType` is BASIC_AUTH.
	//
	// This parameter is not valid for other types of source providers or connections.
	Username *string `field:"optional" json:"username" yaml:"username"`
}

Properties for defining a `CfnSourceCredential`.

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"

cfnSourceCredentialProps := &cfnSourceCredentialProps{
	authType: jsii.String("authType"),
	serverType: jsii.String("serverType"),
	token: jsii.String("token"),

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

type CloudWatchLoggingOptions 

type CloudWatchLoggingOptions struct {
	// The current status of the logs in Amazon CloudWatch Logs for a build project.
	// Experimental.
	Enabled *bool `field:"optional" json:"enabled" yaml:"enabled"`
	// The Log Group to send logs to.
	// Experimental.
	LogGroup awslogs.ILogGroup `field:"optional" json:"logGroup" yaml:"logGroup"`
	// The prefix of the stream name of the Amazon CloudWatch Logs.
	// Experimental.
	Prefix *string `field:"optional" json:"prefix" yaml:"prefix"`
}

Information about logs built to a CloudWatch Log Group for a build project.

Example: 

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	logging: &loggingOptions{
		cloudWatch: &cloudWatchLoggingOptions{
			logGroup: logs.NewLogGroup(this, jsii.String("MyLogGroup")),
		},
	},
})

Experimental.

type CodeCommitSourceProps 

type CodeCommitSourceProps struct {
	// The source identifier.
	//
	// This property is required on secondary sources.
	// Experimental.
	Identifier *string `field:"optional" json:"identifier" yaml:"identifier"`
	// Experimental.
	Repository awscodecommit.IRepository `field:"required" json:"repository" yaml:"repository"`
	// The commit ID, pull request ID, branch name, or tag name that corresponds to the version of the source code you want to build.
	//
	// Example:
	//   "mybranch"
	//
	// Experimental.
	BranchOrRef *string `field:"optional" json:"branchOrRef" yaml:"branchOrRef"`
	// The depth of history to download.
	//
	// Minimum value is 0.
	// If this value is 0, greater than 25, or not provided,
	// then the full history is downloaded with each build of the project.
	// Experimental.
	CloneDepth *float64 `field:"optional" json:"cloneDepth" yaml:"cloneDepth"`
	// Whether to fetch submodules while cloning git repo.
	// Experimental.
	FetchSubmodules *bool `field:"optional" json:"fetchSubmodules" yaml:"fetchSubmodules"`
}

Construction properties for {@link CodeCommitSource}.

Example: 

import codecommit "github.com/aws/aws-cdk-go/awscdk"
var repo repository
var bucket bucket

project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	secondarySources: []iSource{
		codebuild.source.codeCommit(&codeCommitSourceProps{
			identifier: jsii.String("source2"),
			repository: repo,
		}),
	},
	secondaryArtifacts: []iArtifacts{
		codebuild.artifacts.s3(&s3ArtifactsProps{
			identifier: jsii.String("artifact2"),
			bucket: bucket,
			path: jsii.String("some/path"),
			name: jsii.String("file.zip"),
		}),
	},
})

Experimental.

type CommonProjectProps 

type CommonProjectProps struct {
	// Whether to allow the CodeBuild to send all network traffic.
	//
	// If set to false, you must individually add traffic rules to allow the
	// CodeBuild project to connect to network targets.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	AllowAllOutbound *bool `field:"optional" json:"allowAllOutbound" yaml:"allowAllOutbound"`
	// Indicates whether AWS CodeBuild generates a publicly accessible URL for your project's build badge.
	//
	// For more information, see Build Badges Sample
	// in the AWS CodeBuild User Guide.
	// Experimental.
	Badge *bool `field:"optional" json:"badge" yaml:"badge"`
	// Filename or contents of buildspec in JSON format.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-example
	//
	// Experimental.
	BuildSpec BuildSpec `field:"optional" json:"buildSpec" yaml:"buildSpec"`
	// Caching strategy to use.
	// Experimental.
	Cache Cache `field:"optional" json:"cache" yaml:"cache"`
	// Whether to check for the presence of any secrets in the environment variables of the default type, BuildEnvironmentVariableType.PLAINTEXT. Since using a secret for the value of that kind of variable would result in it being displayed in plain text in the AWS Console, the construct will throw an exception if it detects a secret was passed there. Pass this property as false if you want to skip this validation, and keep using a secret in a plain text environment variable.
	// Experimental.
	CheckSecretsInPlainTextEnvVariables *bool `field:"optional" json:"checkSecretsInPlainTextEnvVariables" yaml:"checkSecretsInPlainTextEnvVariables"`
	// Maximum number of concurrent builds.
	//
	// Minimum value is 1 and maximum is account build limit.
	// Experimental.
	ConcurrentBuildLimit *float64 `field:"optional" json:"concurrentBuildLimit" yaml:"concurrentBuildLimit"`
	// A description of the project.
	//
	// Use the description to identify the purpose
	// of the project.
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Encryption key to use to read and write artifacts.
	// Experimental.
	EncryptionKey awskms.IKey `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	// Build environment to use for the build.
	// Experimental.
	Environment *BuildEnvironment `field:"optional" json:"environment" yaml:"environment"`
	// Additional environment variables to add to the build environment.
	// Experimental.
	EnvironmentVariables *map[string]*BuildEnvironmentVariable `field:"optional" json:"environmentVariables" yaml:"environmentVariables"`
	// An  ProjectFileSystemLocation objects for a CodeBuild build project.
	//
	// A ProjectFileSystemLocation object specifies the identifier, location, mountOptions, mountPoint,
	// and type of a file system created using Amazon Elastic File System.
	// Experimental.
	FileSystemLocations *[]IFileSystemLocation `field:"optional" json:"fileSystemLocations" yaml:"fileSystemLocations"`
	// Add permissions to this project's role to create and use test report groups with name starting with the name of this project.
	//
	// That is the standard report group that gets created when a simple name
	// (in contrast to an ARN)
	// is used in the 'reports' section of the buildspec of this project.
	// This is usually harmless, but you can turn these off if you don't plan on using test
	// reports in this project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/test-report-group-naming.html
	//
	// Experimental.
	GrantReportGroupPermissions *bool `field:"optional" json:"grantReportGroupPermissions" yaml:"grantReportGroupPermissions"`
	// Information about logs for the build project.
	//
	// A project can create logs in Amazon CloudWatch Logs, an S3 bucket, or both.
	// Experimental.
	Logging *LoggingOptions `field:"optional" json:"logging" yaml:"logging"`
	// The physical, human-readable name of the CodeBuild Project.
	// Experimental.
	ProjectName *string `field:"optional" json:"projectName" yaml:"projectName"`
	// The number of minutes after which AWS CodeBuild stops the build if it's still in queue.
	//
	// For valid values, see the timeoutInMinutes field in the AWS
	// CodeBuild User Guide.
	// Experimental.
	QueuedTimeout awscdk.Duration `field:"optional" json:"queuedTimeout" yaml:"queuedTimeout"`
	// Service Role to assume while running the build.
	// Experimental.
	Role awsiam.IRole `field:"optional" json:"role" yaml:"role"`
	// What security group to associate with the codebuild project's network interfaces.
	//
	// If no security group is identified, one will be created automatically.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `field:"optional" json:"securityGroups" yaml:"securityGroups"`
	// Where to place the network interfaces within the VPC.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `field:"optional" json:"subnetSelection" yaml:"subnetSelection"`
	// The number of minutes after which AWS CodeBuild stops the build if it's not complete.
	//
	// For valid values, see the timeoutInMinutes field in the AWS
	// CodeBuild User Guide.
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// VPC network to place codebuild network interfaces.
	//
	// Specify this if the codebuild project needs to access resources in a VPC.
	// Experimental.
	Vpc awsec2.IVpc `field:"optional" json:"vpc" yaml:"vpc"`
}

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import monocdk "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
import "github.com/aws/aws-cdk-go/awscdk"
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 buildImage iBuildImage
var buildSpec buildSpec
var cache cache
var duration duration
var fileSystemLocation iFileSystemLocation
var key key
var logGroup logGroup
var role role
var securityGroup securityGroup
var subnet subnet
var subnetFilter subnetFilter
var value interface{}
var vpc vpc

commonProjectProps := &commonProjectProps{
	allowAllOutbound: jsii.Boolean(false),
	badge: jsii.Boolean(false),
	buildSpec: buildSpec,
	cache: cache,
	checkSecretsInPlainTextEnvVariables: jsii.Boolean(false),
	concurrentBuildLimit: jsii.Number(123),
	description: jsii.String("description"),
	encryptionKey: key,
	environment: &buildEnvironment{
		buildImage: buildImage,
		certificate: &buildEnvironmentCertificate{
			bucket: bucket,
			objectKey: jsii.String("objectKey"),
		},
		computeType: awscdk.Aws_codebuild.computeType_SMALL,
		environmentVariables: map[string]buildEnvironmentVariable{
			"environmentVariablesKey": &buildEnvironmentVariable{
				"value": value,

				// the properties below are optional
				"type": awscdk.*Aws_codebuild.BuildEnvironmentVariableType_PLAINTEXT,
			},
		},
		privileged: jsii.Boolean(false),
	},
	environmentVariables: map[string]*buildEnvironmentVariable{
		"environmentVariablesKey": &buildEnvironmentVariable{
			"value": value,

			// the properties below are optional
			"type": awscdk.*Aws_codebuild.BuildEnvironmentVariableType_PLAINTEXT,
		},
	},
	fileSystemLocations: []*iFileSystemLocation{
		fileSystemLocation,
	},
	grantReportGroupPermissions: jsii.Boolean(false),
	logging: &loggingOptions{
		cloudWatch: &cloudWatchLoggingOptions{
			enabled: jsii.Boolean(false),
			logGroup: logGroup,
			prefix: jsii.String("prefix"),
		},
		s3: &s3LoggingOptions{
			bucket: bucket,

			// the properties below are optional
			enabled: jsii.Boolean(false),
			encrypted: jsii.Boolean(false),
			prefix: jsii.String("prefix"),
		},
	},
	projectName: jsii.String("projectName"),
	queuedTimeout: duration,
	role: role,
	securityGroups: []iSecurityGroup{
		securityGroup,
	},
	subnetSelection: &subnetSelection{
		availabilityZones: []*string{
			jsii.String("availabilityZones"),
		},
		onePerAz: jsii.Boolean(false),
		subnetFilters: []*subnetFilter{
			subnetFilter,
		},
		subnetGroupName: jsii.String("subnetGroupName"),
		subnetName: jsii.String("subnetName"),
		subnets: []iSubnet{
			subnet,
		},
		subnetType: awscdk.Aws_ec2.subnetType_ISOLATED,
	},
	timeout: duration,
	vpc: vpc,
}

Experimental.

type ComputeType 

type ComputeType string

Build machine compute type.

Example: 

var vpc vpc
var mySecurityGroup securityGroup

pipelines.NewCodeBuildStep(jsii.String("Synth"), &codeBuildStepProps{
	// ...standard ShellStep props...
	commands: []*string{
	},
	env: map[string]interface{}{
	},

	// If you are using a CodeBuildStep explicitly, set the 'cdk.out' directory
	// to be the synth step's output.
	primaryOutputDirectory: jsii.String("cdk.out"),

	// Control the name of the project
	projectName: jsii.String("MyProject"),

	// Control parts of the BuildSpec other than the regular 'build' and 'install' commands
	partialBuildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),

	// Control the build environment
	buildEnvironment: &buildEnvironment{
		computeType: codebuild.computeType_LARGE,
	},
	timeout: awscdk.Duration.minutes(jsii.Number(90)),

	// Control Elastic Network Interface creation
	vpc: vpc,
	subnetSelection: &subnetSelection{
		subnetType: ec2.subnetType_PRIVATE_WITH_NAT,
	},
	securityGroups: []iSecurityGroup{
		mySecurityGroup,
	},

	// Additional policy statements for the execution role
	rolePolicyStatements: []policyStatement{
		iam.NewPolicyStatement(&policyStatementProps{
		}),
	},
})

Experimental. 

const (
	// Experimental.
	ComputeType_SMALL ComputeType = "SMALL"
	// Experimental.
	ComputeType_MEDIUM ComputeType = "MEDIUM"
	// Experimental.
	ComputeType_LARGE ComputeType = "LARGE"
	// Experimental.
	ComputeType_X2_LARGE ComputeType = "X2_LARGE"
)

type DockerImageOptions 

type DockerImageOptions struct {
	// The credentials, stored in Secrets Manager, used for accessing the repository holding the image, if the repository is private.
	// Experimental.
	SecretsManagerCredentials awssecretsmanager.ISecret `field:"optional" json:"secretsManagerCredentials" yaml:"secretsManagerCredentials"`
}

The options when creating a CodeBuild Docker build image using {@link LinuxBuildImage.fromDockerRegistry} or {@link WindowsBuildImage.fromDockerRegistry}.

Example: 

environment: &buildEnvironment{
	buildImage: codebuild.linuxBuildImage.fromDockerRegistry(jsii.String("my-registry/my-repo"), &dockerImageOptions{
		secretsManagerCredentials: secrets,
	}),
},

Experimental.

type EfsFileSystemLocationProps 

type EfsFileSystemLocationProps struct {
	// The name used to access a file system created by Amazon EFS.
	// Experimental.
	Identifier *string `field:"required" json:"identifier" yaml:"identifier"`
	// A string that specifies the location of the file system, like Amazon EFS.
	//
	// This value looks like `fs-abcd1234.efs.us-west-2.amazonaws.com:/my-efs-mount-directory`.
	// Experimental.
	Location *string `field:"required" json:"location" yaml:"location"`
	// The location in the container where you mount the file system.
	// Experimental.
	MountPoint *string `field:"required" json:"mountPoint" yaml:"mountPoint"`
	// The mount options for a file system such as Amazon EFS.
	// Experimental.
	MountOptions *string `field:"optional" json:"mountOptions" yaml:"mountOptions"`
}

Construction properties for {@link EfsFileSystemLocation}.

Example: 

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),
	fileSystemLocations: []iFileSystemLocation{
		codebuild.fileSystemLocation.efs(&efsFileSystemLocationProps{
			identifier: jsii.String("myidentifier2"),
			location: jsii.String("myclodation.mydnsroot.com:/loc"),
			mountPoint: jsii.String("/media"),
			mountOptions: jsii.String("opts"),
		}),
	},
})

Experimental.

type EventAction 

type EventAction string

The types of webhook event actions.

Example: 

gitHubSource := codebuild.source.gitHub(&gitHubSourceProps{
	owner: jsii.String("awslabs"),
	repo: jsii.String("aws-cdk"),
	webhook: jsii.Boolean(true),
	 // optional, default: true if `webhookFilters` were provided, false otherwise
	webhookTriggersBatchBuild: jsii.Boolean(true),
	 // optional, default is false
	webhookFilters: []filterGroup{
		codebuild.*filterGroup.inEventOf(codebuild.eventAction_PUSH).andBranchIs(jsii.String("master")).andCommitMessageIs(jsii.String("the commit message")),
	},
})

Experimental. 

const (
	// A push (of a branch, or a tag) to the repository.
	// Experimental.
	EventAction_PUSH EventAction = "PUSH"
	// Creating a Pull Request.
	// Experimental.
	EventAction_PULL_REQUEST_CREATED EventAction = "PULL_REQUEST_CREATED"
	// Updating a Pull Request.
	// Experimental.
	EventAction_PULL_REQUEST_UPDATED EventAction = "PULL_REQUEST_UPDATED"
	// Merging a Pull Request.
	// Experimental.
	EventAction_PULL_REQUEST_MERGED EventAction = "PULL_REQUEST_MERGED"
	// Re-opening a previously closed Pull Request.
	//
	// Note that this event is only supported for GitHub and GitHubEnterprise sources.
	// Experimental.
	EventAction_PULL_REQUEST_REOPENED EventAction = "PULL_REQUEST_REOPENED"
)

type FileSystemConfig 

type FileSystemConfig struct {
	// File system location wrapper property.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-codebuild-project-projectfilesystemlocation.html
	//
	// Experimental.
	Location *CfnProject_ProjectFileSystemLocationProperty `field:"required" json:"location" yaml:"location"`
}

The type returned from {@link IFileSystemLocation#bind}.

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"

fileSystemConfig := &fileSystemConfig{
	location: &projectFileSystemLocationProperty{
		identifier: jsii.String("identifier"),
		location: jsii.String("location"),
		mountPoint: jsii.String("mountPoint"),
		type: jsii.String("type"),

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

Experimental.

type FileSystemLocation 

type FileSystemLocation interface {
}

FileSystemLocation provider definition for a CodeBuild Project.

Example: 

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),
	fileSystemLocations: []iFileSystemLocation{
		codebuild.fileSystemLocation.efs(&efsFileSystemLocationProps{
			identifier: jsii.String("myidentifier2"),
			location: jsii.String("myclodation.mydnsroot.com:/loc"),
			mountPoint: jsii.String("/media"),
			mountOptions: jsii.String("opts"),
		}),
	},
})

Experimental.

func NewFileSystemLocation 

func NewFileSystemLocation() FileSystemLocation

Experimental.

type FilterGroup 

type FilterGroup interface {
	// Create a new FilterGroup with an added condition: the account ID of the actor initiating the event must match the given pattern.
	// Experimental.
	AndActorAccountIs(pattern *string) FilterGroup
	// Create a new FilterGroup with an added condition: the account ID of the actor initiating the event must not match the given pattern.
	// Experimental.
	AndActorAccountIsNot(pattern *string) FilterGroup
	// Create a new FilterGroup with an added condition: the Pull Request that is the source of the event must target the given base branch.
	//
	// Note that you cannot use this method if this Group contains the `PUSH` event action.
	// Experimental.
	AndBaseBranchIs(branchName *string) FilterGroup
	// Create a new FilterGroup with an added condition: the Pull Request that is the source of the event must not target the given base branch.
	//
	// Note that you cannot use this method if this Group contains the `PUSH` event action.
	// Experimental.
	AndBaseBranchIsNot(branchName *string) FilterGroup
	// Create a new FilterGroup with an added condition: the Pull Request that is the source of the event must target the given Git reference.
	//
	// Note that you cannot use this method if this Group contains the `PUSH` event action.
	// Experimental.
	AndBaseRefIs(pattern *string) FilterGroup
	// Create a new FilterGroup with an added condition: the Pull Request that is the source of the event must not target the given Git reference.
	//
	// Note that you cannot use this method if this Group contains the `PUSH` event action.
	// Experimental.
	AndBaseRefIsNot(pattern *string) FilterGroup
	// Create a new FilterGroup with an added condition: the event must affect the given branch.
	// Experimental.
	AndBranchIs(branchName *string) FilterGroup
	// Create a new FilterGroup with an added condition: the event must not affect the given branch.
	// Experimental.
	AndBranchIsNot(branchName *string) FilterGroup
	// Create a new FilterGroup with an added condition: the event must affect a head commit with the given message.
	// Experimental.
	AndCommitMessageIs(commitMessage *string) FilterGroup
	// Create a new FilterGroup with an added condition: the event must not affect a head commit with the given message.
	// Experimental.
	AndCommitMessageIsNot(commitMessage *string) FilterGroup
	// Create a new FilterGroup with an added condition: the push that is the source of the event must affect a file that matches the given pattern.
	//
	// Note that you can only use this method if this Group contains only the `PUSH` event action,
	// and only for GitHub, Bitbucket and GitHubEnterprise sources.
	// Experimental.
	AndFilePathIs(pattern *string) FilterGroup
	// Create a new FilterGroup with an added condition: the push that is the source of the event must not affect a file that matches the given pattern.
	//
	// Note that you can only use this method if this Group contains only the `PUSH` event action,
	// and only for GitHub, Bitbucket and GitHubEnterprise sources.
	// Experimental.
	AndFilePathIsNot(pattern *string) FilterGroup
	// Create a new FilterGroup with an added condition: the event must affect a Git reference (ie., a branch or a tag) that matches the given pattern.
	// Experimental.
	AndHeadRefIs(pattern *string) FilterGroup
	// Create a new FilterGroup with an added condition: the event must not affect a Git reference (ie., a branch or a tag) that matches the given pattern.
	// Experimental.
	AndHeadRefIsNot(pattern *string) FilterGroup
	// Create a new FilterGroup with an added condition: the event must affect the given tag.
	// Experimental.
	AndTagIs(tagName *string) FilterGroup
	// Create a new FilterGroup with an added condition: the event must not affect the given tag.
	// Experimental.
	AndTagIsNot(tagName *string) FilterGroup
}

An object that represents a group of filter conditions for a webhook.

Every condition in a given FilterGroup must be true in order for the whole group to be true. You construct instances of it by calling the {@link #inEventOf} static factory method, and then calling various `andXyz` instance methods to create modified instances of it (this class is immutable).

You pass instances of this class to the `webhookFilters` property when constructing a source.

Example: 

gitHubSource := codebuild.source.gitHub(&gitHubSourceProps{
	owner: jsii.String("awslabs"),
	repo: jsii.String("aws-cdk"),
	webhook: jsii.Boolean(true),
	 // optional, default: true if `webhookFilters` were provided, false otherwise
	webhookTriggersBatchBuild: jsii.Boolean(true),
	 // optional, default is false
	webhookFilters: []filterGroup{
		codebuild.*filterGroup.inEventOf(codebuild.eventAction_PUSH).andBranchIs(jsii.String("master")).andCommitMessageIs(jsii.String("the commit message")),
	},
})

Experimental.

func FilterGroup_InEventOf 

func FilterGroup_InEventOf(actions ...EventAction) FilterGroup

Creates a new event FilterGroup that triggers on any of the provided actions. Experimental.

type GitHubEnterpriseSourceCredentials 

type GitHubEnterpriseSourceCredentials interface {
	awscdk.Resource
	// 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.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// 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.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// 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`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	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`.
	// Experimental.
	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.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	Validate() *[]*string
}

The source credentials used when contacting the GitHub Enterprise API.

**Note**: CodeBuild only allows a single credential for GitHub Enterprise to be saved in a given AWS account in a given region - any attempt to add more than one will result in an error.

Example: 

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

var secretValue secretValue

gitHubEnterpriseSourceCredentials := awscdk.Aws_codebuild.NewGitHubEnterpriseSourceCredentials(this, jsii.String("MyGitHubEnterpriseSourceCredentials"), &gitHubEnterpriseSourceCredentialsProps{
	accessToken: secretValue,
})

Experimental.

func NewGitHubEnterpriseSourceCredentials 

func NewGitHubEnterpriseSourceCredentials(scope constructs.Construct, id *string, props *GitHubEnterpriseSourceCredentialsProps) GitHubEnterpriseSourceCredentials

Experimental.

type GitHubEnterpriseSourceCredentialsProps 

type GitHubEnterpriseSourceCredentialsProps struct {
	// The personal access token to use when contacting the instance of the GitHub Enterprise API.
	// Experimental.
	AccessToken awscdk.SecretValue `field:"required" json:"accessToken" yaml:"accessToken"`
}

Creation properties for {@link GitHubEnterpriseSourceCredentials}.

Example: 

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

var secretValue secretValue

gitHubEnterpriseSourceCredentialsProps := &gitHubEnterpriseSourceCredentialsProps{
	accessToken: secretValue,
}

Experimental.

type GitHubEnterpriseSourceProps 

type GitHubEnterpriseSourceProps struct {
	// The source identifier.
	//
	// This property is required on secondary sources.
	// Experimental.
	Identifier *string `field:"optional" json:"identifier" yaml:"identifier"`
	// The HTTPS URL of the repository in your GitHub Enterprise installation.
	// Experimental.
	HttpsCloneUrl *string `field:"required" json:"httpsCloneUrl" yaml:"httpsCloneUrl"`
	// The commit ID, pull request ID, branch name, or tag name that corresponds to the version of the source code you want to build.
	//
	// Example:
	//   "mybranch"
	//
	// Experimental.
	BranchOrRef *string `field:"optional" json:"branchOrRef" yaml:"branchOrRef"`
	// This parameter is used for the `context` parameter in the GitHub commit status.
	//
	// Can use built-in CodeBuild variables, like $AWS_REGION.
	//
	// Example:
	//   "My build #$CODEBUILD_BUILD_NUMBER"
	//
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
	//
	// Experimental.
	BuildStatusContext *string `field:"optional" json:"buildStatusContext" yaml:"buildStatusContext"`
	// The URL that the build will report back to the source provider.
	//
	// Can use built-in CodeBuild variables, like $AWS_REGION.
	//
	// Example:
	//   "$CODEBUILD_PUBLIC_BUILD_URL"
	//
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
	//
	// Experimental.
	BuildStatusUrl *string `field:"optional" json:"buildStatusUrl" yaml:"buildStatusUrl"`
	// The depth of history to download.
	//
	// Minimum value is 0.
	// If this value is 0, greater than 25, or not provided,
	// then the full history is downloaded with each build of the project.
	// Experimental.
	CloneDepth *float64 `field:"optional" json:"cloneDepth" yaml:"cloneDepth"`
	// Whether to fetch submodules while cloning git repo.
	// Experimental.
	FetchSubmodules *bool `field:"optional" json:"fetchSubmodules" yaml:"fetchSubmodules"`
	// Whether to ignore SSL errors when connecting to the repository.
	// Experimental.
	IgnoreSslErrors *bool `field:"optional" json:"ignoreSslErrors" yaml:"ignoreSslErrors"`
	// Whether to send notifications on your build's start and end.
	// Experimental.
	ReportBuildStatus *bool `field:"optional" json:"reportBuildStatus" yaml:"reportBuildStatus"`
	// Whether to create a webhook that will trigger a build every time an event happens in the repository.
	// Experimental.
	Webhook *bool `field:"optional" json:"webhook" yaml:"webhook"`
	// A list of webhook filters that can constraint what events in the repository will trigger a build.
	//
	// A build is triggered if any of the provided filter groups match.
	// Only valid if `webhook` was not provided as false.
	// Experimental.
	WebhookFilters *[]FilterGroup `field:"optional" json:"webhookFilters" yaml:"webhookFilters"`
	// Trigger a batch build from a webhook instead of a standard one.
	//
	// Enabling this will enable batch builds on the CodeBuild project.
	// Experimental.
	WebhookTriggersBatchBuild *bool `field:"optional" json:"webhookTriggersBatchBuild" yaml:"webhookTriggersBatchBuild"`
}

Construction properties for {@link GitHubEnterpriseSource}.

Example: 

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	source: codebuild.source.gitHubEnterprise(&gitHubEnterpriseSourceProps{
		httpsCloneUrl: jsii.String("https://my-github-enterprise.com/owner/repo"),
	}),

	// Enable Docker AND custom caching
	cache: codebuild.cache.local(codebuild.localCacheMode_DOCKER_LAYER, codebuild.*localCacheMode_CUSTOM),

	// BuildSpec with a 'cache' section necessary for 'CUSTOM' caching. This can
	// also come from 'buildspec.yml' in your source.
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("..."),
				},
			},
		},
		"cache": map[string][]*string{
			"paths": []*string{
				jsii.String("/root/cachedir/**/*"),
			},
		},
	}),
})

Experimental.

type GitHubSourceCredentials 

type GitHubSourceCredentials interface {
	awscdk.Resource
	// 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.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// 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.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// 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`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	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`.
	// Experimental.
	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.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	Validate() *[]*string
}

The source credentials used when contacting the GitHub API.

**Note**: CodeBuild only allows a single credential for GitHub to be saved in a given AWS account in a given region - any attempt to add more than one will result in an error.

Example: 

codebuild.NewGitHubSourceCredentials(this, jsii.String("CodeBuildGitHubCreds"), &gitHubSourceCredentialsProps{
	accessToken: awscdk.SecretValue.secretsManager(jsii.String("my-token")),
})

Experimental.

func NewGitHubSourceCredentials 

func NewGitHubSourceCredentials(scope constructs.Construct, id *string, props *GitHubSourceCredentialsProps) GitHubSourceCredentials

Experimental.

type GitHubSourceCredentialsProps 

type GitHubSourceCredentialsProps struct {
	// The personal access token to use when contacting the GitHub API.
	// Experimental.
	AccessToken awscdk.SecretValue `field:"required" json:"accessToken" yaml:"accessToken"`
}

Creation properties for {@link GitHubSourceCredentials}.

Example: 

codebuild.NewGitHubSourceCredentials(this, jsii.String("CodeBuildGitHubCreds"), &gitHubSourceCredentialsProps{
	accessToken: awscdk.SecretValue.secretsManager(jsii.String("my-token")),
})

Experimental.

type GitHubSourceProps 

type GitHubSourceProps struct {
	// The source identifier.
	//
	// This property is required on secondary sources.
	// Experimental.
	Identifier *string `field:"optional" json:"identifier" yaml:"identifier"`
	// The GitHub account/user that owns the repo.
	//
	// Example:
	//   "awslabs"
	//
	// Experimental.
	Owner *string `field:"required" json:"owner" yaml:"owner"`
	// The name of the repo (without the username).
	//
	// Example:
	//   "aws-cdk"
	//
	// Experimental.
	Repo *string `field:"required" json:"repo" yaml:"repo"`
	// The commit ID, pull request ID, branch name, or tag name that corresponds to the version of the source code you want to build.
	//
	// Example:
	//   "mybranch"
	//
	// Experimental.
	BranchOrRef *string `field:"optional" json:"branchOrRef" yaml:"branchOrRef"`
	// This parameter is used for the `context` parameter in the GitHub commit status.
	//
	// Can use built-in CodeBuild variables, like $AWS_REGION.
	//
	// Example:
	//   "My build #$CODEBUILD_BUILD_NUMBER"
	//
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
	//
	// Experimental.
	BuildStatusContext *string `field:"optional" json:"buildStatusContext" yaml:"buildStatusContext"`
	// The URL that the build will report back to the source provider.
	//
	// Can use built-in CodeBuild variables, like $AWS_REGION.
	//
	// Example:
	//   "$CODEBUILD_PUBLIC_BUILD_URL"
	//
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-env-vars.html
	//
	// Experimental.
	BuildStatusUrl *string `field:"optional" json:"buildStatusUrl" yaml:"buildStatusUrl"`
	// The depth of history to download.
	//
	// Minimum value is 0.
	// If this value is 0, greater than 25, or not provided,
	// then the full history is downloaded with each build of the project.
	// Experimental.
	CloneDepth *float64 `field:"optional" json:"cloneDepth" yaml:"cloneDepth"`
	// Whether to fetch submodules while cloning git repo.
	// Experimental.
	FetchSubmodules *bool `field:"optional" json:"fetchSubmodules" yaml:"fetchSubmodules"`
	// Whether to send notifications on your build's start and end.
	// Experimental.
	ReportBuildStatus *bool `field:"optional" json:"reportBuildStatus" yaml:"reportBuildStatus"`
	// Whether to create a webhook that will trigger a build every time an event happens in the repository.
	// Experimental.
	Webhook *bool `field:"optional" json:"webhook" yaml:"webhook"`
	// A list of webhook filters that can constraint what events in the repository will trigger a build.
	//
	// A build is triggered if any of the provided filter groups match.
	// Only valid if `webhook` was not provided as false.
	// Experimental.
	WebhookFilters *[]FilterGroup `field:"optional" json:"webhookFilters" yaml:"webhookFilters"`
	// Trigger a batch build from a webhook instead of a standard one.
	//
	// Enabling this will enable batch builds on the CodeBuild project.
	// Experimental.
	WebhookTriggersBatchBuild *bool `field:"optional" json:"webhookTriggersBatchBuild" yaml:"webhookTriggersBatchBuild"`
}

Construction properties for {@link GitHubSource} and {@link GitHubEnterpriseSource}.

Example: 

gitHubSource := codebuild.source.gitHub(&gitHubSourceProps{
	owner: jsii.String("awslabs"),
	repo: jsii.String("aws-cdk"),
	webhook: jsii.Boolean(true),
	 // optional, default: true if `webhookFilters` were provided, false otherwise
	webhookTriggersBatchBuild: jsii.Boolean(true),
	 // optional, default is false
	webhookFilters: []filterGroup{
		codebuild.*filterGroup.inEventOf(codebuild.eventAction_PUSH).andBranchIs(jsii.String("master")).andCommitMessageIs(jsii.String("the commit message")),
	},
})

Experimental.

type IArtifacts 

type IArtifacts interface {
	// Callback when an Artifacts class is used in a CodeBuild Project.
	// Experimental.
	Bind(scope awscdk.Construct, project IProject) *ArtifactsConfig
	// The artifact identifier.
	//
	// This property is required on secondary artifacts.
	// Experimental.
	Identifier() *string
	// The CodeBuild type of this artifact.
	// Experimental.
	Type() *string
}

The abstract interface of a CodeBuild build output.

Implemented by {@link Artifacts}. Experimental.

func Artifacts_S3 

func Artifacts_S3(props *S3ArtifactsProps) IArtifacts

Experimental.

type IBindableBuildImage 

type IBindableBuildImage interface {
	IBuildImage
	// Function that allows the build image access to the construct tree.
	// Experimental.
	Bind(scope awscdk.Construct, project IProject, options *BuildImageBindOptions) *BuildImageConfig
}

A variant of {@link IBuildImage} that allows binding to the project. Experimental.

type IBuildImage 

type IBuildImage interface {
	// Make a buildspec to run the indicated script.
	// Experimental.
	RunScriptBuildspec(entrypoint *string) BuildSpec
	// Allows the image a chance to validate whether the passed configuration is correct.
	// Experimental.
	Validate(buildEnvironment *BuildEnvironment) *[]*string
	// The default {@link ComputeType} to use with this image, if one was not specified in {@link BuildEnvironment#computeType} explicitly.
	// Experimental.
	DefaultComputeType() ComputeType
	// The Docker image identifier that the build environment uses.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html
	//
	// Experimental.
	ImageId() *string
	// The type of principal that CodeBuild will use to pull this build Docker image.
	// Experimental.
	ImagePullPrincipalType() ImagePullPrincipalType
	// An optional ECR repository that the image is hosted in.
	// Experimental.
	Repository() awsecr.IRepository
	// The secretsManagerCredentials for access to a private registry.
	// Experimental.
	SecretsManagerCredentials() awssecretsmanager.ISecret
	// The type of build environment.
	// Experimental.
	Type() *string
}

Represents a Docker image used for the CodeBuild Project builds.

Use the concrete subclasses, either: {@link LinuxBuildImage} or {@link WindowsBuildImage}. Experimental.

func LinuxArmBuildImage_AMAZON_LINUX_2_STANDARD_1_0 

func LinuxArmBuildImage_AMAZON_LINUX_2_STANDARD_1_0() IBuildImage

func LinuxArmBuildImage_AMAZON_LINUX_2_STANDARD_2_0 

func LinuxArmBuildImage_AMAZON_LINUX_2_STANDARD_2_0() IBuildImage

func LinuxArmBuildImage_FromCodeBuildImageId 

func LinuxArmBuildImage_FromCodeBuildImageId(id *string) IBuildImage

Uses a Docker image provided by CodeBuild.

Returns: A Docker image provided by CodeBuild.

Example: 

"aws/codebuild/amazonlinux2-aarch64-standard:1.0"

See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html

Experimental.

func LinuxArmBuildImage_FromEcrRepository 

func LinuxArmBuildImage_FromEcrRepository(repository awsecr.IRepository, tagOrDigest *string) IBuildImage

Returns an ARM image running Linux from an ECR repository.

NOTE: if the repository is external (i.e. imported), then we won't be able to add a resource policy statement for it so CodeBuild can pull the image.

Returns: An aarch64 Linux build image from an ECR repository. See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-ecr.html

Experimental.

func LinuxBuildImage_AMAZON_LINUX_2 

func LinuxBuildImage_AMAZON_LINUX_2() IBuildImage

func LinuxBuildImage_AMAZON_LINUX_2_2 

func LinuxBuildImage_AMAZON_LINUX_2_2() IBuildImage

func LinuxBuildImage_AMAZON_LINUX_2_3 

func LinuxBuildImage_AMAZON_LINUX_2_3() IBuildImage

func LinuxBuildImage_AMAZON_LINUX_2_ARM 

func LinuxBuildImage_AMAZON_LINUX_2_ARM() IBuildImage

func LinuxBuildImage_AMAZON_LINUX_2_ARM_2 

func LinuxBuildImage_AMAZON_LINUX_2_ARM_2() IBuildImage

func LinuxBuildImage_FromAsset 

func LinuxBuildImage_FromAsset(scope constructs.Construct, id *string, props *awsecrassets.DockerImageAssetProps) IBuildImage

Uses an Docker image asset as a x86-64 Linux build image. Experimental.

func LinuxBuildImage_FromCodeBuildImageId 

func LinuxBuildImage_FromCodeBuildImageId(id *string) IBuildImage

Uses a Docker image provided by CodeBuild.

Returns: A Docker image provided by CodeBuild.

Example: 

"aws/codebuild/standard:4.0"

See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html

Experimental.

func LinuxBuildImage_FromDockerRegistry 

func LinuxBuildImage_FromDockerRegistry(name *string, options *DockerImageOptions) IBuildImage

Returns: a x86-64 Linux build image from a Docker Hub image. Experimental.

func LinuxBuildImage_FromEcrRepository 

func LinuxBuildImage_FromEcrRepository(repository awsecr.IRepository, tagOrDigest *string) IBuildImage

Returns: A x86-64 Linux build image from an ECR repository.

NOTE: if the repository is external (i.e. imported), then we won't be able to add a resource policy statement for it so CodeBuild can pull the image. See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-ecr.html

Experimental.

func LinuxBuildImage_STANDARD_1_0 

func LinuxBuildImage_STANDARD_1_0() IBuildImage

func LinuxBuildImage_STANDARD_2_0 

func LinuxBuildImage_STANDARD_2_0() IBuildImage

func LinuxBuildImage_STANDARD_3_0 

func LinuxBuildImage_STANDARD_3_0() IBuildImage

func LinuxBuildImage_STANDARD_4_0 

func LinuxBuildImage_STANDARD_4_0() IBuildImage

func LinuxBuildImage_STANDARD_5_0 

func LinuxBuildImage_STANDARD_5_0() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_ANDROID_JAVA8_24_4_1 

func LinuxBuildImage_UBUNTU_14_04_ANDROID_JAVA8_24_4_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_ANDROID_JAVA8_26_1_1 

func LinuxBuildImage_UBUNTU_14_04_ANDROID_JAVA8_26_1_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_BASE 

func LinuxBuildImage_UBUNTU_14_04_BASE() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_DOCKER_17_09_0 

func LinuxBuildImage_UBUNTU_14_04_DOCKER_17_09_0() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_DOCKER_18_09_0 

func LinuxBuildImage_UBUNTU_14_04_DOCKER_18_09_0() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_DOTNET_CORE_1_1 

func LinuxBuildImage_UBUNTU_14_04_DOTNET_CORE_1_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_DOTNET_CORE_2_0 

func LinuxBuildImage_UBUNTU_14_04_DOTNET_CORE_2_0() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_DOTNET_CORE_2_1 

func LinuxBuildImage_UBUNTU_14_04_DOTNET_CORE_2_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_GOLANG_1_10 

func LinuxBuildImage_UBUNTU_14_04_GOLANG_1_10() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_GOLANG_1_11 

func LinuxBuildImage_UBUNTU_14_04_GOLANG_1_11() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_NODEJS_10_14_1 

func LinuxBuildImage_UBUNTU_14_04_NODEJS_10_14_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_NODEJS_10_1_0 

func LinuxBuildImage_UBUNTU_14_04_NODEJS_10_1_0() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_NODEJS_6_3_1 

func LinuxBuildImage_UBUNTU_14_04_NODEJS_6_3_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_NODEJS_8_11_0 

func LinuxBuildImage_UBUNTU_14_04_NODEJS_8_11_0() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_OPEN_JDK_11 

func LinuxBuildImage_UBUNTU_14_04_OPEN_JDK_11() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_OPEN_JDK_8 

func LinuxBuildImage_UBUNTU_14_04_OPEN_JDK_8() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_OPEN_JDK_9 

func LinuxBuildImage_UBUNTU_14_04_OPEN_JDK_9() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PHP_5_6 

func LinuxBuildImage_UBUNTU_14_04_PHP_5_6() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PHP_7_0 

func LinuxBuildImage_UBUNTU_14_04_PHP_7_0() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PHP_7_1 

func LinuxBuildImage_UBUNTU_14_04_PHP_7_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PYTHON_2_7_12 

func LinuxBuildImage_UBUNTU_14_04_PYTHON_2_7_12() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_3_6 

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_3_6() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_4_5 

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_4_5() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_5_2 

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_5_2() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_6_5 

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_6_5() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_7_1 

func LinuxBuildImage_UBUNTU_14_04_PYTHON_3_7_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_RUBY_2_2_5 

func LinuxBuildImage_UBUNTU_14_04_RUBY_2_2_5() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_RUBY_2_3_1 

func LinuxBuildImage_UBUNTU_14_04_RUBY_2_3_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_RUBY_2_5_1 

func LinuxBuildImage_UBUNTU_14_04_RUBY_2_5_1() IBuildImage

func LinuxBuildImage_UBUNTU_14_04_RUBY_2_5_3 

func LinuxBuildImage_UBUNTU_14_04_RUBY_2_5_3() IBuildImage

func LinuxGpuBuildImage_AwsDeepLearningContainersImage 

func LinuxGpuBuildImage_AwsDeepLearningContainersImage(repositoryName *string, tag *string, account *string) IBuildImage

Returns a Linux GPU build image from AWS Deep Learning Containers. See: https://aws.amazon.com/releasenotes/available-deep-learning-containers-images

Experimental.

func LinuxGpuBuildImage_DLC_MXNET_1_4_1 

func LinuxGpuBuildImage_DLC_MXNET_1_4_1() IBuildImage

func LinuxGpuBuildImage_DLC_MXNET_1_6_0 

func LinuxGpuBuildImage_DLC_MXNET_1_6_0() IBuildImage

func LinuxGpuBuildImage_DLC_PYTORCH_1_2_0 

func LinuxGpuBuildImage_DLC_PYTORCH_1_2_0() IBuildImage

func LinuxGpuBuildImage_DLC_PYTORCH_1_3_1 

func LinuxGpuBuildImage_DLC_PYTORCH_1_3_1() IBuildImage

func LinuxGpuBuildImage_DLC_PYTORCH_1_4_0_INFERENCE 

func LinuxGpuBuildImage_DLC_PYTORCH_1_4_0_INFERENCE() IBuildImage

func LinuxGpuBuildImage_DLC_PYTORCH_1_4_0_TRAINING 

func LinuxGpuBuildImage_DLC_PYTORCH_1_4_0_TRAINING() IBuildImage

func LinuxGpuBuildImage_DLC_PYTORCH_1_5_0_INFERENCE 

func LinuxGpuBuildImage_DLC_PYTORCH_1_5_0_INFERENCE() IBuildImage

func LinuxGpuBuildImage_DLC_PYTORCH_1_5_0_TRAINING 

func LinuxGpuBuildImage_DLC_PYTORCH_1_5_0_TRAINING() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_1_14_0 

func LinuxGpuBuildImage_DLC_TENSORFLOW_1_14_0() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_1_15_0 

func LinuxGpuBuildImage_DLC_TENSORFLOW_1_15_0() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_1_15_2_INFERENCE 

func LinuxGpuBuildImage_DLC_TENSORFLOW_1_15_2_INFERENCE() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_1_15_2_TRAINING 

func LinuxGpuBuildImage_DLC_TENSORFLOW_1_15_2_TRAINING() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_0_0 

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_0_0() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_0_1 

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_0_1() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_1_0_INFERENCE 

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_1_0_INFERENCE() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_1_0_TRAINING 

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_1_0_TRAINING() IBuildImage

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_2_0_TRAINING 

func LinuxGpuBuildImage_DLC_TENSORFLOW_2_2_0_TRAINING() IBuildImage

func LinuxGpuBuildImage_FromEcrRepository 

func LinuxGpuBuildImage_FromEcrRepository(repository awsecr.IRepository, tag *string) IBuildImage

Returns a GPU image running Linux from an ECR repository.

NOTE: if the repository is external (i.e. imported), then we won't be able to add a resource policy statement for it so CodeBuild can pull the image. See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-ecr.html

Experimental.

func WindowsBuildImage_FromAsset 

func WindowsBuildImage_FromAsset(scope constructs.Construct, id *string, props *awsecrassets.DockerImageAssetProps, imageType WindowsImageType) IBuildImage

Uses an Docker image asset as a Windows build image. Experimental.

func WindowsBuildImage_FromDockerRegistry 

func WindowsBuildImage_FromDockerRegistry(name *string, options *DockerImageOptions, imageType WindowsImageType) IBuildImage

Returns: a Windows build image from a Docker Hub image. Experimental.

func WindowsBuildImage_FromEcrRepository 

func WindowsBuildImage_FromEcrRepository(repository awsecr.IRepository, tagOrDigest *string, imageType WindowsImageType) IBuildImage

Returns: A Windows build image from an ECR repository.

NOTE: if the repository is external (i.e. imported), then we won't be able to add a resource policy statement for it so CodeBuild can pull the image. See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-ecr.html

Experimental.

func WindowsBuildImage_WINDOWS_BASE_2_0 

func WindowsBuildImage_WINDOWS_BASE_2_0() IBuildImage

func WindowsBuildImage_WIN_SERVER_CORE_2016_BASE 

func WindowsBuildImage_WIN_SERVER_CORE_2016_BASE() IBuildImage

func WindowsBuildImage_WIN_SERVER_CORE_2019_BASE 

func WindowsBuildImage_WIN_SERVER_CORE_2019_BASE() IBuildImage

type IFileSystemLocation 

type IFileSystemLocation interface {
	// Called by the project when a file system is added so it can perform binding operations on this file system location.
	// Experimental.
	Bind(scope awscdk.Construct, project IProject) *FileSystemConfig
}

The interface of a CodeBuild FileSystemLocation.

Implemented by {@link EfsFileSystemLocation}. Experimental.

func FileSystemLocation_Efs 

func FileSystemLocation_Efs(props *EfsFileSystemLocationProps) IFileSystemLocation

EFS file system provider. Experimental.

type IProject 

type IProject interface {
	awsec2.IConnectable
	awsiam.IGrantable
	awscodestarnotifications.INotificationRuleSource
	awscdk.IResource
	// Experimental.
	AddToRolePolicy(policyStatement awsiam.PolicyStatement)
	// Enable batch builds.
	//
	// Returns an object contining the batch service role if batch builds
	// could be enabled.
	// Experimental.
	EnableBatchBuilds() *BatchBuildConfig
	// Returns: a CloudWatch metric associated with this build project.
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of builds triggered.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the duration of all builds over time.
	//
	// Units: Seconds
	//
	// Valid CloudWatch statistics: Average (recommended), Maximum, Minimum.
	// Experimental.
	MetricDuration(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of builds that failed because of client error or because of a timeout.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricFailedBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of successful builds.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricSucceededBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Defines a CodeStar Notification rule triggered when the project events emitted by you specified, it very similar to `onEvent` API.
	//
	// You can also use the methods `notifyOnBuildSucceeded` and
	// `notifyOnBuildFailed` to define rules for these specific event emitted.
	//
	// Returns: CodeStar Notifications rule associated with this build project.
	// Experimental.
	NotifyOn(id *string, target awscodestarnotifications.INotificationRuleTarget, options *ProjectNotifyOnOptions) awscodestarnotifications.INotificationRule
	// Defines a CodeStar notification rule which triggers when a build fails.
	// Experimental.
	NotifyOnBuildFailed(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Defines a CodeStar notification rule which triggers when a build completes successfully.
	// Experimental.
	NotifyOnBuildSucceeded(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Defines an event rule which triggers when a build fails.
	// Experimental.
	OnBuildFailed(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines an event rule which triggers when a build starts.
	// Experimental.
	OnBuildStarted(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines an event rule which triggers when a build completes successfully.
	// Experimental.
	OnBuildSucceeded(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule triggered when something happens with this project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule that triggers upon phase change of this build project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnPhaseChange(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule triggered when the build project state changes.
	//
	// You can filter specific build status events using an event
	// pattern filter on the `build-status` detail field:
	//
	//     const rule = project.onStateChange('OnBuildStarted', { target });
	//     rule.addEventPattern({
	//       detail: {
	//         'build-status': [
	//           "IN_PROGRESS",
	//           "SUCCEEDED",
	//           "FAILED",
	//           "STOPPED"
	//         ]
	//       }
	//     });
	//
	// You can also use the methods `onBuildFailed` and `onBuildSucceeded` to define rules for
	// these specific state changes.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnStateChange(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// The ARN of this Project.
	// Experimental.
	ProjectArn() *string
	// The human-visible name of this Project.
	// Experimental.
	ProjectName() *string
	// The IAM service Role of this Project.
	//
	// Undefined for imported Projects.
	// Experimental.
	Role() awsiam.IRole
}

Experimental.

func PipelineProject_FromProjectArn 

func PipelineProject_FromProjectArn(scope constructs.Construct, id *string, projectArn *string) IProject

Experimental.

func PipelineProject_FromProjectName 

func PipelineProject_FromProjectName(scope constructs.Construct, id *string, projectName *string) IProject

Import a Project defined either outside the CDK, or in a different CDK Stack (and exported using the {@link export} method).

Returns: a reference to the existing Project. Experimental.

func Project_FromProjectArn 

func Project_FromProjectArn(scope constructs.Construct, id *string, projectArn *string) IProject

Experimental.

func Project_FromProjectName 

func Project_FromProjectName(scope constructs.Construct, id *string, projectName *string) IProject

Import a Project defined either outside the CDK, or in a different CDK Stack (and exported using the {@link export} method).

Returns: a reference to the existing Project. Experimental.

type IReportGroup 

type IReportGroup interface {
	awscdk.IResource
	// Grants the given entity permissions to write (that is, upload reports to) this report group.
	// Experimental.
	GrantWrite(identity awsiam.IGrantable) awsiam.Grant
	// The ARN of the ReportGroup.
	// Experimental.
	ReportGroupArn() *string
	// The name of the ReportGroup.
	// Experimental.
	ReportGroupName() *string
}

The interface representing the ReportGroup resource - either an existing one, imported using the {@link ReportGroup.fromReportGroupName} method, or a new one, created with the {@link ReportGroup} class. Experimental.

func ReportGroup_FromReportGroupName 

func ReportGroup_FromReportGroupName(scope constructs.Construct, id *string, reportGroupName *string) IReportGroup

Reference an existing ReportGroup, defined outside of the CDK code, by name. Experimental.

type ISource 

type ISource interface {
	// Experimental.
	Bind(scope awscdk.Construct, project IProject) *SourceConfig
	// Experimental.
	BadgeSupported() *bool
	// Experimental.
	Identifier() *string
	// Experimental.
	Type() *string
}

The abstract interface of a CodeBuild source.

Implemented by {@link Source}. Experimental.

func Source_BitBucket 

func Source_BitBucket(props *BitBucketSourceProps) ISource

Experimental.

func Source_CodeCommit 

func Source_CodeCommit(props *CodeCommitSourceProps) ISource

Experimental.

func Source_GitHub 

func Source_GitHub(props *GitHubSourceProps) ISource

Experimental.

func Source_GitHubEnterprise 

func Source_GitHubEnterprise(props *GitHubEnterpriseSourceProps) ISource

Experimental.

func Source_S3 

func Source_S3(props *S3SourceProps) ISource

Experimental.

type ImagePullPrincipalType 

type ImagePullPrincipalType string

The type of principal CodeBuild will use to pull your build Docker image. Experimental. 

const (
	// CODEBUILD specifies that CodeBuild uses its own identity when pulling the image.
	//
	// This means the resource policy of the ECR repository that hosts the image will be modified to trust
	// CodeBuild's service principal.
	// This is the required principal type when using CodeBuild's pre-defined images.
	// Experimental.
	ImagePullPrincipalType_CODEBUILD ImagePullPrincipalType = "CODEBUILD"
	// SERVICE_ROLE specifies that AWS CodeBuild uses the project's role when pulling the image.
	//
	// The role will be granted pull permissions on the ECR repository hosting the image.
	// Experimental.
	ImagePullPrincipalType_SERVICE_ROLE ImagePullPrincipalType = "SERVICE_ROLE"
)

type LinuxArmBuildImage 

type LinuxArmBuildImage interface {
	IBuildImage
	// The default {@link ComputeType} to use with this image, if one was not specified in {@link BuildEnvironment#computeType} explicitly.
	// Experimental.
	DefaultComputeType() ComputeType
	// The Docker image identifier that the build environment uses.
	// Experimental.
	ImageId() *string
	// The type of principal that CodeBuild will use to pull this build Docker image.
	// Experimental.
	ImagePullPrincipalType() ImagePullPrincipalType
	// An optional ECR repository that the image is hosted in.
	// Experimental.
	Repository() awsecr.IRepository
	// The secretsManagerCredentials for access to a private registry.
	// Experimental.
	SecretsManagerCredentials() awssecretsmanager.ISecret
	// The type of build environment.
	// Experimental.
	Type() *string
	// Make a buildspec to run the indicated script.
	// Experimental.
	RunScriptBuildspec(entrypoint *string) BuildSpec
	// Validates by checking the BuildEnvironment computeType as aarch64 images only support ComputeType.SMALL and ComputeType.LARGE.
	// Experimental.
	Validate(buildEnvironment *BuildEnvironment) *[]*string
}

A CodeBuild image running aarch64 Linux.

This class has a bunch of public constants that represent the CodeBuild ARM images.

You can also specify a custom image using the static method:

- LinuxBuildImage.fromEcrRepository(repo[, tag])

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"

linuxArmBuildImage := awscdk.Aws_codebuild.linuxArmBuildImage.fromCodeBuildImageId(jsii.String("id"))

See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html

Experimental.

type LinuxBuildImage 

type LinuxBuildImage interface {
	IBuildImage
	// The default {@link ComputeType} to use with this image, if one was not specified in {@link BuildEnvironment#computeType} explicitly.
	// Experimental.
	DefaultComputeType() ComputeType
	// The Docker image identifier that the build environment uses.
	// Experimental.
	ImageId() *string
	// The type of principal that CodeBuild will use to pull this build Docker image.
	// Experimental.
	ImagePullPrincipalType() ImagePullPrincipalType
	// An optional ECR repository that the image is hosted in.
	// Experimental.
	Repository() awsecr.IRepository
	// The secretsManagerCredentials for access to a private registry.
	// Experimental.
	SecretsManagerCredentials() awssecretsmanager.ISecret
	// The type of build environment.
	// Experimental.
	Type() *string
	// Make a buildspec to run the indicated script.
	// Experimental.
	RunScriptBuildspec(entrypoint *string) BuildSpec
	// Allows the image a chance to validate whether the passed configuration is correct.
	// Experimental.
	Validate(_arg *BuildEnvironment) *[]*string
}

A CodeBuild image running x86-64 Linux.

This class has a bunch of public constants that represent the most popular images.

You can also specify a custom image using one of the static methods:

- LinuxBuildImage.fromDockerRegistry(image[, { secretsManagerCredentials }]) - LinuxBuildImage.fromEcrRepository(repo[, tag]) - LinuxBuildImage.fromAsset(parent, id, props)

Example: 

pipeline := pipelines.NewCodePipeline(this, jsii.String("Pipeline"), &codePipelineProps{
	synth: pipelines.NewShellStep(jsii.String("Synth"), &shellStepProps{
		input: pipelines.codePipelineSource.connection(jsii.String("my-org/my-app"), jsii.String("main"), &connectionSourceOptions{
			connectionArn: jsii.String("arn:aws:codestar-connections:us-east-1:222222222222:connection/7d2469ff-514a-4e4f-9003-5ca4a43cdc41"),
		}),
		commands: []*string{
			jsii.String("npm ci"),
			jsii.String("npm run build"),
			jsii.String("npx cdk synth"),
		},
	}),

	// Turn this on because the pipeline uses Docker image assets
	dockerEnabledForSelfMutation: jsii.Boolean(true),
})

pipeline.addWave(jsii.String("MyWave"), &waveOptions{
	post: []step{
		pipelines.NewCodeBuildStep(jsii.String("RunApproval"), &codeBuildStepProps{
			commands: []*string{
				jsii.String("command-from-image"),
			},
			buildEnvironment: &buildEnvironment{
				// The user of a Docker image asset in the pipeline requires turning on
				// 'dockerEnabledForSelfMutation'.
				buildImage: codebuild.linuxBuildImage.fromAsset(this, jsii.String("Image"), &dockerImageAssetProps{
					directory: jsii.String("./docker-image"),
				}),
			},
		}),
	},
})

See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html

Experimental.

type LinuxGpuBuildImage 

type LinuxGpuBuildImage interface {
	IBindableBuildImage
	// The default {@link ComputeType} to use with this image, if one was not specified in {@link BuildEnvironment#computeType} explicitly.
	// Experimental.
	DefaultComputeType() ComputeType
	// The Docker image identifier that the build environment uses.
	// Experimental.
	ImageId() *string
	// The type of principal that CodeBuild will use to pull this build Docker image.
	// Experimental.
	ImagePullPrincipalType() ImagePullPrincipalType
	// The type of build environment.
	// Experimental.
	Type() *string
	// Function that allows the build image access to the construct tree.
	// Experimental.
	Bind(scope awscdk.Construct, project IProject, _options *BuildImageBindOptions) *BuildImageConfig
	// Make a buildspec to run the indicated script.
	// Experimental.
	RunScriptBuildspec(entrypoint *string) BuildSpec
	// Allows the image a chance to validate whether the passed configuration is correct.
	// Experimental.
	Validate(buildEnvironment *BuildEnvironment) *[]*string
}

A CodeBuild GPU image running Linux.

This class has public constants that represent the most popular GPU images from AWS Deep Learning Containers.

Example: 

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	environment: &buildEnvironment{
		buildImage: codebuild.linuxGpuBuildImage_DLC_TENSORFLOW_2_1_0_INFERENCE(),
	},
})

See: https://aws.amazon.com/releasenotes/available-deep-learning-containers-images

Experimental.

type LocalCacheMode 

type LocalCacheMode string

Local cache modes to enable for the CodeBuild Project.

Example: 

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	source: codebuild.source.gitHubEnterprise(&gitHubEnterpriseSourceProps{
		httpsCloneUrl: jsii.String("https://my-github-enterprise.com/owner/repo"),
	}),

	// Enable Docker AND custom caching
	cache: codebuild.cache.local(codebuild.localCacheMode_DOCKER_LAYER, codebuild.*localCacheMode_CUSTOM),

	// BuildSpec with a 'cache' section necessary for 'CUSTOM' caching. This can
	// also come from 'buildspec.yml' in your source.
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("..."),
				},
			},
		},
		"cache": map[string][]*string{
			"paths": []*string{
				jsii.String("/root/cachedir/**/*"),
			},
		},
	}),
})

Experimental. 

const (
	// Caches Git metadata for primary and secondary sources.
	// Experimental.
	LocalCacheMode_SOURCE LocalCacheMode = "SOURCE"
	// Caches existing Docker layers.
	// Experimental.
	LocalCacheMode_DOCKER_LAYER LocalCacheMode = "DOCKER_LAYER"
	// Caches directories you specify in the buildspec file.
	// Experimental.
	LocalCacheMode_CUSTOM LocalCacheMode = "CUSTOM"
)

type LoggingOptions 

type LoggingOptions struct {
	// Information about Amazon CloudWatch Logs for a build project.
	// Experimental.
	CloudWatch *CloudWatchLoggingOptions `field:"optional" json:"cloudWatch" yaml:"cloudWatch"`
	// Information about logs built to an S3 bucket for a build project.
	// Experimental.
	S3 *S3LoggingOptions `field:"optional" json:"s3" yaml:"s3"`
}

Information about logs for the build project.

A project can create logs in Amazon CloudWatch Logs, an S3 bucket, or both.

Example: 

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	logging: &loggingOptions{
		cloudWatch: &cloudWatchLoggingOptions{
			logGroup: logs.NewLogGroup(this, jsii.String("MyLogGroup")),
		},
	},
})

Experimental.

type PhaseChangeEvent 

type PhaseChangeEvent interface {
}

Event fields for the CodeBuild "phase change" event. See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html#sample-build-notifications-ref

Experimental.

type PipelineProject 

type PipelineProject interface {
	Project
	// Access the Connections object.
	//
	// Will fail if this Project does not have a VPC set.
	// Experimental.
	Connections() awsec2.Connections
	// 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.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// 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.
	// Experimental.
	PhysicalName() *string
	// The ARN of the project.
	// Experimental.
	ProjectArn() *string
	// The name of the project.
	// Experimental.
	ProjectName() *string
	// The IAM role for this project.
	// Experimental.
	Role() awsiam.IRole
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Adds a fileSystemLocation to the Project.
	// Experimental.
	AddFileSystemLocation(fileSystemLocation IFileSystemLocation)
	// Adds a secondary artifact to the Project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html
	//
	// Experimental.
	AddSecondaryArtifact(secondaryArtifact IArtifacts)
	// Adds a secondary source to the Project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html
	//
	// Experimental.
	AddSecondarySource(secondarySource ISource)
	// Add a permission only if there's a policy attached.
	// Experimental.
	AddToRolePolicy(statement awsiam.PolicyStatement)
	// 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`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns a source configuration for notification rule.
	// Experimental.
	BindAsNotificationRuleSource(_scope constructs.Construct) *awscodestarnotifications.NotificationRuleSourceConfig
	// A callback invoked when the given project is added to a CodePipeline.
	// Experimental.
	BindToCodePipeline(_scope awscdk.Construct, options *BindToCodePipelineOptions)
	// Enable batch builds.
	//
	// Returns an object contining the batch service role if batch builds
	// could be enabled.
	// Experimental.
	EnableBatchBuilds() *BatchBuildConfig
	// Experimental.
	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`.
	// Experimental.
	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.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns: a CloudWatch metric associated with this build project.
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of builds triggered.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the duration of all builds over time.
	//
	// Units: Seconds
	//
	// Valid CloudWatch statistics: Average (recommended), Maximum, Minimum.
	// Experimental.
	MetricDuration(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of builds that failed because of client error or because of a timeout.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricFailedBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of successful builds.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricSucceededBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Defines a CodeStar Notification rule triggered when the project events emitted by you specified, it very similar to `onEvent` API.
	//
	// You can also use the methods `notifyOnBuildSucceeded` and
	// `notifyOnBuildFailed` to define rules for these specific event emitted.
	// Experimental.
	NotifyOn(id *string, target awscodestarnotifications.INotificationRuleTarget, options *ProjectNotifyOnOptions) awscodestarnotifications.INotificationRule
	// Defines a CodeStar notification rule which triggers when a build fails.
	// Experimental.
	NotifyOnBuildFailed(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Defines a CodeStar notification rule which triggers when a build completes successfully.
	// Experimental.
	NotifyOnBuildSucceeded(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Defines an event rule which triggers when a build fails.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// Experimental.
	OnBuildFailed(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines an event rule which triggers when a build starts.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// Experimental.
	OnBuildStarted(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines an event rule which triggers when a build completes successfully.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// Experimental.
	OnBuildSucceeded(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule triggered when something happens with this project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule that triggers upon phase change of this build project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnPhaseChange(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Defines a CloudWatch event rule triggered when the build project state changes.
	//
	// You can filter specific build status events using an event
	// pattern filter on the `build-status` detail field:
	//
	//     const rule = project.onStateChange('OnBuildStarted', { target });
	//     rule.addEventPattern({
	//       detail: {
	//         'build-status': [
	//           "IN_PROGRESS",
	//           "SUCCEEDED",
	//           "FAILED",
	//           "STOPPED"
	//         ]
	//       }
	//     });
	//
	// You can also use the methods `onBuildFailed` and `onBuildSucceeded` to define rules for
	// these specific state changes.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnStateChange(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	// Experimental.
	Validate() *[]*string
}

A convenience class for CodeBuild Projects that are used in CodePipeline.

Example: 

// Create a Cloudfront Web Distribution
import cloudfront "github.com/aws/aws-cdk-go/awscdk"
var distribution distribution

// Create the build project that will invalidate the cache
invalidateBuildProject := codebuild.NewPipelineProject(this, jsii.String("InvalidateProject"), &pipelineProjectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("aws cloudfront create-invalidation --distribution-id ${CLOUDFRONT_ID} --paths \"/*\""),
				},
			},
		},
	}),
	environmentVariables: map[string]buildEnvironmentVariable{
		"CLOUDFRONT_ID": &buildEnvironmentVariable{
			"value": distribution.distributionId,
		},
	},
})

// Add Cloudfront invalidation permissions to the project
distributionArn := fmt.Sprintf("arn:aws:cloudfront::%v:distribution/%v", this.account, distribution.distributionId)
invalidateBuildProject.addToRolePolicy(iam.NewPolicyStatement(&policyStatementProps{
	resources: []*string{
		distributionArn,
	},
	actions: []*string{
		jsii.String("cloudfront:CreateInvalidation"),
	},
}))

// Create the pipeline (here only the S3 deploy and Invalidate cache build)
deployBucket := s3.NewBucket(this, jsii.String("DeployBucket"))
deployInput := codepipeline.NewArtifact()
codepipeline.NewPipeline(this, jsii.String("Pipeline"), &pipelineProps{
	stages: []stageProps{
		&stageProps{
			stageName: jsii.String("Deploy"),
			actions: []iAction{
				codepipeline_actions.NewS3DeployAction(&s3DeployActionProps{
					actionName: jsii.String("S3Deploy"),
					bucket: deployBucket,
					input: deployInput,
					runOrder: jsii.Number(1),
				}),
				codepipeline_actions.NewCodeBuildAction(&codeBuildActionProps{
					actionName: jsii.String("InvalidateCache"),
					project: invalidateBuildProject,
					input: deployInput,
					runOrder: jsii.Number(2),
				}),
			},
		},
	},
})

Experimental.

func NewPipelineProject 

func NewPipelineProject(scope constructs.Construct, id *string, props *PipelineProjectProps) PipelineProject

Experimental.

type PipelineProjectProps 

type PipelineProjectProps struct {
	// Whether to allow the CodeBuild to send all network traffic.
	//
	// If set to false, you must individually add traffic rules to allow the
	// CodeBuild project to connect to network targets.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	AllowAllOutbound *bool `field:"optional" json:"allowAllOutbound" yaml:"allowAllOutbound"`
	// Indicates whether AWS CodeBuild generates a publicly accessible URL for your project's build badge.
	//
	// For more information, see Build Badges Sample
	// in the AWS CodeBuild User Guide.
	// Experimental.
	Badge *bool `field:"optional" json:"badge" yaml:"badge"`
	// Filename or contents of buildspec in JSON format.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-example
	//
	// Experimental.
	BuildSpec BuildSpec `field:"optional" json:"buildSpec" yaml:"buildSpec"`
	// Caching strategy to use.
	// Experimental.
	Cache Cache `field:"optional" json:"cache" yaml:"cache"`
	// Whether to check for the presence of any secrets in the environment variables of the default type, BuildEnvironmentVariableType.PLAINTEXT. Since using a secret for the value of that kind of variable would result in it being displayed in plain text in the AWS Console, the construct will throw an exception if it detects a secret was passed there. Pass this property as false if you want to skip this validation, and keep using a secret in a plain text environment variable.
	// Experimental.
	CheckSecretsInPlainTextEnvVariables *bool `field:"optional" json:"checkSecretsInPlainTextEnvVariables" yaml:"checkSecretsInPlainTextEnvVariables"`
	// Maximum number of concurrent builds.
	//
	// Minimum value is 1 and maximum is account build limit.
	// Experimental.
	ConcurrentBuildLimit *float64 `field:"optional" json:"concurrentBuildLimit" yaml:"concurrentBuildLimit"`
	// A description of the project.
	//
	// Use the description to identify the purpose
	// of the project.
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Encryption key to use to read and write artifacts.
	// Experimental.
	EncryptionKey awskms.IKey `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	// Build environment to use for the build.
	// Experimental.
	Environment *BuildEnvironment `field:"optional" json:"environment" yaml:"environment"`
	// Additional environment variables to add to the build environment.
	// Experimental.
	EnvironmentVariables *map[string]*BuildEnvironmentVariable `field:"optional" json:"environmentVariables" yaml:"environmentVariables"`
	// An  ProjectFileSystemLocation objects for a CodeBuild build project.
	//
	// A ProjectFileSystemLocation object specifies the identifier, location, mountOptions, mountPoint,
	// and type of a file system created using Amazon Elastic File System.
	// Experimental.
	FileSystemLocations *[]IFileSystemLocation `field:"optional" json:"fileSystemLocations" yaml:"fileSystemLocations"`
	// Add permissions to this project's role to create and use test report groups with name starting with the name of this project.
	//
	// That is the standard report group that gets created when a simple name
	// (in contrast to an ARN)
	// is used in the 'reports' section of the buildspec of this project.
	// This is usually harmless, but you can turn these off if you don't plan on using test
	// reports in this project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/test-report-group-naming.html
	//
	// Experimental.
	GrantReportGroupPermissions *bool `field:"optional" json:"grantReportGroupPermissions" yaml:"grantReportGroupPermissions"`
	// Information about logs for the build project.
	//
	// A project can create logs in Amazon CloudWatch Logs, an S3 bucket, or both.
	// Experimental.
	Logging *LoggingOptions `field:"optional" json:"logging" yaml:"logging"`
	// The physical, human-readable name of the CodeBuild Project.
	// Experimental.
	ProjectName *string `field:"optional" json:"projectName" yaml:"projectName"`
	// The number of minutes after which AWS CodeBuild stops the build if it's still in queue.
	//
	// For valid values, see the timeoutInMinutes field in the AWS
	// CodeBuild User Guide.
	// Experimental.
	QueuedTimeout awscdk.Duration `field:"optional" json:"queuedTimeout" yaml:"queuedTimeout"`
	// Service Role to assume while running the build.
	// Experimental.
	Role awsiam.IRole `field:"optional" json:"role" yaml:"role"`
	// What security group to associate with the codebuild project's network interfaces.
	//
	// If no security group is identified, one will be created automatically.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `field:"optional" json:"securityGroups" yaml:"securityGroups"`
	// Where to place the network interfaces within the VPC.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `field:"optional" json:"subnetSelection" yaml:"subnetSelection"`
	// The number of minutes after which AWS CodeBuild stops the build if it's not complete.
	//
	// For valid values, see the timeoutInMinutes field in the AWS
	// CodeBuild User Guide.
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// VPC network to place codebuild network interfaces.
	//
	// Specify this if the codebuild project needs to access resources in a VPC.
	// Experimental.
	Vpc awsec2.IVpc `field:"optional" json:"vpc" yaml:"vpc"`
}

Example: 

// Create a Cloudfront Web Distribution
import cloudfront "github.com/aws/aws-cdk-go/awscdk"
var distribution distribution

// Create the build project that will invalidate the cache
invalidateBuildProject := codebuild.NewPipelineProject(this, jsii.String("InvalidateProject"), &pipelineProjectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
		"phases": map[string]map[string][]*string{
			"build": map[string][]*string{
				"commands": []*string{
					jsii.String("aws cloudfront create-invalidation --distribution-id ${CLOUDFRONT_ID} --paths \"/*\""),
				},
			},
		},
	}),
	environmentVariables: map[string]buildEnvironmentVariable{
		"CLOUDFRONT_ID": &buildEnvironmentVariable{
			"value": distribution.distributionId,
		},
	},
})

// Add Cloudfront invalidation permissions to the project
distributionArn := fmt.Sprintf("arn:aws:cloudfront::%v:distribution/%v", this.account, distribution.distributionId)
invalidateBuildProject.addToRolePolicy(iam.NewPolicyStatement(&policyStatementProps{
	resources: []*string{
		distributionArn,
	},
	actions: []*string{
		jsii.String("cloudfront:CreateInvalidation"),
	},
}))

// Create the pipeline (here only the S3 deploy and Invalidate cache build)
deployBucket := s3.NewBucket(this, jsii.String("DeployBucket"))
deployInput := codepipeline.NewArtifact()
codepipeline.NewPipeline(this, jsii.String("Pipeline"), &pipelineProps{
	stages: []stageProps{
		&stageProps{
			stageName: jsii.String("Deploy"),
			actions: []iAction{
				codepipeline_actions.NewS3DeployAction(&s3DeployActionProps{
					actionName: jsii.String("S3Deploy"),
					bucket: deployBucket,
					input: deployInput,
					runOrder: jsii.Number(1),
				}),
				codepipeline_actions.NewCodeBuildAction(&codeBuildActionProps{
					actionName: jsii.String("InvalidateCache"),
					project: invalidateBuildProject,
					input: deployInput,
					runOrder: jsii.Number(2),
				}),
			},
		},
	},
})

Experimental.

type Project 

type Project interface {
	awscdk.Resource
	IProject
	// Access the Connections object.
	//
	// Will fail if this Project does not have a VPC set.
	// Experimental.
	Connections() awsec2.Connections
	// 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.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// The principal to grant permissions to.
	// Experimental.
	GrantPrincipal() awsiam.IPrincipal
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// 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.
	// Experimental.
	PhysicalName() *string
	// The ARN of the project.
	// Experimental.
	ProjectArn() *string
	// The name of the project.
	// Experimental.
	ProjectName() *string
	// The IAM role for this project.
	// Experimental.
	Role() awsiam.IRole
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Adds a fileSystemLocation to the Project.
	// Experimental.
	AddFileSystemLocation(fileSystemLocation IFileSystemLocation)
	// Adds a secondary artifact to the Project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html
	//
	// Experimental.
	AddSecondaryArtifact(secondaryArtifact IArtifacts)
	// Adds a secondary source to the Project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html
	//
	// Experimental.
	AddSecondarySource(secondarySource ISource)
	// Add a permission only if there's a policy attached.
	// Experimental.
	AddToRolePolicy(statement awsiam.PolicyStatement)
	// 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`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Returns a source configuration for notification rule.
	// Experimental.
	BindAsNotificationRuleSource(_scope constructs.Construct) *awscodestarnotifications.NotificationRuleSourceConfig
	// A callback invoked when the given project is added to a CodePipeline.
	// Experimental.
	BindToCodePipeline(_scope awscdk.Construct, options *BindToCodePipelineOptions)
	// Enable batch builds.
	//
	// Returns an object contining the batch service role if batch builds
	// could be enabled.
	// Experimental.
	EnableBatchBuilds() *BatchBuildConfig
	// Experimental.
	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`.
	// Experimental.
	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.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Returns: a CloudWatch metric associated with this build project.
	// Experimental.
	Metric(metricName *string, props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of builds triggered.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the duration of all builds over time.
	//
	// Units: Seconds
	//
	// Valid CloudWatch statistics: Average (recommended), Maximum, Minimum.
	// Experimental.
	MetricDuration(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of builds that failed because of client error or because of a timeout.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricFailedBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Measures the number of successful builds.
	//
	// Units: Count
	//
	// Valid CloudWatch statistics: Sum.
	// Experimental.
	MetricSucceededBuilds(props *awscloudwatch.MetricOptions) awscloudwatch.Metric
	// Defines a CodeStar Notification rule triggered when the project events emitted by you specified, it very similar to `onEvent` API.
	//
	// You can also use the methods `notifyOnBuildSucceeded` and
	// `notifyOnBuildFailed` to define rules for these specific event emitted.
	// Experimental.
	NotifyOn(id *string, target awscodestarnotifications.INotificationRuleTarget, options *ProjectNotifyOnOptions) awscodestarnotifications.INotificationRule
	// Defines a CodeStar notification rule which triggers when a build fails.
	// Experimental.
	NotifyOnBuildFailed(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Defines a CodeStar notification rule which triggers when a build completes successfully.
	// Experimental.
	NotifyOnBuildSucceeded(id *string, target awscodestarnotifications.INotificationRuleTarget, options *awscodestarnotifications.NotificationRuleOptions) awscodestarnotifications.INotificationRule
	// Defines an event rule which triggers when a build fails.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// Experimental.
	OnBuildFailed(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines an event rule which triggers when a build starts.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// Experimental.
	OnBuildStarted(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines an event rule which triggers when a build completes successfully.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// Experimental.
	OnBuildSucceeded(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule triggered when something happens with this project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnEvent(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Defines a CloudWatch event rule that triggers upon phase change of this build project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnPhaseChange(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Defines a CloudWatch event rule triggered when the build project state changes.
	//
	// You can filter specific build status events using an event
	// pattern filter on the `build-status` detail field:
	//
	//     const rule = project.onStateChange('OnBuildStarted', { target });
	//     rule.addEventPattern({
	//       detail: {
	//         'build-status': [
	//           "IN_PROGRESS",
	//           "SUCCEEDED",
	//           "FAILED",
	//           "STOPPED"
	//         ]
	//       }
	//     });
	//
	// You can also use the methods `onBuildFailed` and `onBuildSucceeded` to define rules for
	// these specific state changes.
	//
	// To access fields from the event in the event target input,
	// use the static fields on the `StateChangeEvent` class.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html
	//
	// Experimental.
	OnStateChange(id *string, options *awsevents.OnEventOptions) awsevents.Rule
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	// Experimental.
	Validate() *[]*string
}

A representation of a CodeBuild Project.

Example: 

var bucket bucket

project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),
	artifacts: codebuild.artifacts.s3(&s3ArtifactsProps{
		bucket: bucket,
		includeBuildId: jsii.Boolean(false),
		packageZip: jsii.Boolean(true),
		path: jsii.String("another/path"),
		identifier: jsii.String("AddArtifact1"),
	}),
})

Experimental.

func NewProject 

func NewProject(scope constructs.Construct, id *string, props *ProjectProps) Project

Experimental.

type ProjectNotificationEvents 

type ProjectNotificationEvents string

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

Experimental. 

const (
	// Trigger notification when project build state failed.
	// Experimental.
	ProjectNotificationEvents_BUILD_FAILED ProjectNotificationEvents = "BUILD_FAILED"
	// Trigger notification when project build state succeeded.
	// Experimental.
	ProjectNotificationEvents_BUILD_SUCCEEDED ProjectNotificationEvents = "BUILD_SUCCEEDED"
	// Trigger notification when project build state in progress.
	// Experimental.
	ProjectNotificationEvents_BUILD_IN_PROGRESS ProjectNotificationEvents = "BUILD_IN_PROGRESS"
	// Trigger notification when project build state stopped.
	// Experimental.
	ProjectNotificationEvents_BUILD_STOPPED ProjectNotificationEvents = "BUILD_STOPPED"
	// Trigger notification when project build phase failure.
	// Experimental.
	ProjectNotificationEvents_BUILD_PHASE_FAILED ProjectNotificationEvents = "BUILD_PHASE_FAILED"
	// Trigger notification when project build phase success.
	// Experimental.
	ProjectNotificationEvents_BUILD_PHASE_SUCCEEDED ProjectNotificationEvents = "BUILD_PHASE_SUCCEEDED"
)

type ProjectNotifyOnOptions 

type ProjectNotifyOnOptions 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.
	// Experimental.
	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.
	// Experimental.
	Enabled *bool `field:"optional" json:"enabled" yaml:"enabled"`
	// The name for the notification rule.
	//
	// Notification rule names must be unique in your AWS account.
	// Experimental.
	NotificationRuleName *string `field:"optional" json:"notificationRuleName" yaml:"notificationRuleName"`
	// A list of event types associated with this notification rule for CodeBuild Project.
	//
	// 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
	//
	// Experimental.
	Events *[]ProjectNotificationEvents `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"

projectNotifyOnOptions := &projectNotifyOnOptions{
	events: []projectNotificationEvents{
		awscdk.Aws_codebuild.*projectNotificationEvents_BUILD_FAILED,
	},

	// the properties below are optional
	detailType: awscdk.Aws_codestarnotifications.detailType_BASIC,
	enabled: jsii.Boolean(false),
	notificationRuleName: jsii.String("notificationRuleName"),
}

Experimental.

type ProjectProps 

type ProjectProps struct {
	// Whether to allow the CodeBuild to send all network traffic.
	//
	// If set to false, you must individually add traffic rules to allow the
	// CodeBuild project to connect to network targets.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	AllowAllOutbound *bool `field:"optional" json:"allowAllOutbound" yaml:"allowAllOutbound"`
	// Indicates whether AWS CodeBuild generates a publicly accessible URL for your project's build badge.
	//
	// For more information, see Build Badges Sample
	// in the AWS CodeBuild User Guide.
	// Experimental.
	Badge *bool `field:"optional" json:"badge" yaml:"badge"`
	// Filename or contents of buildspec in JSON format.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec-ref-example
	//
	// Experimental.
	BuildSpec BuildSpec `field:"optional" json:"buildSpec" yaml:"buildSpec"`
	// Caching strategy to use.
	// Experimental.
	Cache Cache `field:"optional" json:"cache" yaml:"cache"`
	// Whether to check for the presence of any secrets in the environment variables of the default type, BuildEnvironmentVariableType.PLAINTEXT. Since using a secret for the value of that kind of variable would result in it being displayed in plain text in the AWS Console, the construct will throw an exception if it detects a secret was passed there. Pass this property as false if you want to skip this validation, and keep using a secret in a plain text environment variable.
	// Experimental.
	CheckSecretsInPlainTextEnvVariables *bool `field:"optional" json:"checkSecretsInPlainTextEnvVariables" yaml:"checkSecretsInPlainTextEnvVariables"`
	// Maximum number of concurrent builds.
	//
	// Minimum value is 1 and maximum is account build limit.
	// Experimental.
	ConcurrentBuildLimit *float64 `field:"optional" json:"concurrentBuildLimit" yaml:"concurrentBuildLimit"`
	// A description of the project.
	//
	// Use the description to identify the purpose
	// of the project.
	// Experimental.
	Description *string `field:"optional" json:"description" yaml:"description"`
	// Encryption key to use to read and write artifacts.
	// Experimental.
	EncryptionKey awskms.IKey `field:"optional" json:"encryptionKey" yaml:"encryptionKey"`
	// Build environment to use for the build.
	// Experimental.
	Environment *BuildEnvironment `field:"optional" json:"environment" yaml:"environment"`
	// Additional environment variables to add to the build environment.
	// Experimental.
	EnvironmentVariables *map[string]*BuildEnvironmentVariable `field:"optional" json:"environmentVariables" yaml:"environmentVariables"`
	// An  ProjectFileSystemLocation objects for a CodeBuild build project.
	//
	// A ProjectFileSystemLocation object specifies the identifier, location, mountOptions, mountPoint,
	// and type of a file system created using Amazon Elastic File System.
	// Experimental.
	FileSystemLocations *[]IFileSystemLocation `field:"optional" json:"fileSystemLocations" yaml:"fileSystemLocations"`
	// Add permissions to this project's role to create and use test report groups with name starting with the name of this project.
	//
	// That is the standard report group that gets created when a simple name
	// (in contrast to an ARN)
	// is used in the 'reports' section of the buildspec of this project.
	// This is usually harmless, but you can turn these off if you don't plan on using test
	// reports in this project.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/test-report-group-naming.html
	//
	// Experimental.
	GrantReportGroupPermissions *bool `field:"optional" json:"grantReportGroupPermissions" yaml:"grantReportGroupPermissions"`
	// Information about logs for the build project.
	//
	// A project can create logs in Amazon CloudWatch Logs, an S3 bucket, or both.
	// Experimental.
	Logging *LoggingOptions `field:"optional" json:"logging" yaml:"logging"`
	// The physical, human-readable name of the CodeBuild Project.
	// Experimental.
	ProjectName *string `field:"optional" json:"projectName" yaml:"projectName"`
	// The number of minutes after which AWS CodeBuild stops the build if it's still in queue.
	//
	// For valid values, see the timeoutInMinutes field in the AWS
	// CodeBuild User Guide.
	// Experimental.
	QueuedTimeout awscdk.Duration `field:"optional" json:"queuedTimeout" yaml:"queuedTimeout"`
	// Service Role to assume while running the build.
	// Experimental.
	Role awsiam.IRole `field:"optional" json:"role" yaml:"role"`
	// What security group to associate with the codebuild project's network interfaces.
	//
	// If no security group is identified, one will be created automatically.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SecurityGroups *[]awsec2.ISecurityGroup `field:"optional" json:"securityGroups" yaml:"securityGroups"`
	// Where to place the network interfaces within the VPC.
	//
	// Only used if 'vpc' is supplied.
	// Experimental.
	SubnetSelection *awsec2.SubnetSelection `field:"optional" json:"subnetSelection" yaml:"subnetSelection"`
	// The number of minutes after which AWS CodeBuild stops the build if it's not complete.
	//
	// For valid values, see the timeoutInMinutes field in the AWS
	// CodeBuild User Guide.
	// Experimental.
	Timeout awscdk.Duration `field:"optional" json:"timeout" yaml:"timeout"`
	// VPC network to place codebuild network interfaces.
	//
	// Specify this if the codebuild project needs to access resources in a VPC.
	// Experimental.
	Vpc awsec2.IVpc `field:"optional" json:"vpc" yaml:"vpc"`
	// Defines where build artifacts will be stored.
	//
	// Could be: PipelineBuildArtifacts, NoArtifacts and S3Artifacts.
	// Experimental.
	Artifacts IArtifacts `field:"optional" json:"artifacts" yaml:"artifacts"`
	// The secondary artifacts for the Project.
	//
	// Can also be added after the Project has been created by using the {@link Project#addSecondaryArtifact} method.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html
	//
	// Experimental.
	SecondaryArtifacts *[]IArtifacts `field:"optional" json:"secondaryArtifacts" yaml:"secondaryArtifacts"`
	// The secondary sources for the Project.
	//
	// Can be also added after the Project has been created by using the {@link Project#addSecondarySource} method.
	// See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-multi-in-out.html
	//
	// Experimental.
	SecondarySources *[]ISource `field:"optional" json:"secondarySources" yaml:"secondarySources"`
	// The source of the build.
	//
	// *Note*: if {@link NoSource} is given as the source,
	// then you need to provide an explicit `buildSpec`.
	// Experimental.
	Source ISource `field:"optional" json:"source" yaml:"source"`
}

Example: 

var bucket bucket

project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),
	artifacts: codebuild.artifacts.s3(&s3ArtifactsProps{
		bucket: bucket,
		includeBuildId: jsii.Boolean(false),
		packageZip: jsii.Boolean(true),
		path: jsii.String("another/path"),
		identifier: jsii.String("AddArtifact1"),
	}),
})

Experimental.

type ReportGroup 

type ReportGroup interface {
	awscdk.Resource
	IReportGroup
	// 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.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// Experimental.
	ExportBucket() awss3.IBucket
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// 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.
	// Experimental.
	PhysicalName() *string
	// The ARN of the ReportGroup.
	// Experimental.
	ReportGroupArn() *string
	// The name of the ReportGroup.
	// Experimental.
	ReportGroupName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// 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`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Experimental.
	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`.
	// Experimental.
	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.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Grants the given entity permissions to write (that is, upload reports to) this report group.
	// Experimental.
	GrantWrite(identity awsiam.IGrantable) awsiam.Grant
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	Validate() *[]*string
}

The ReportGroup resource class.

Example: 

var source source

// create a new ReportGroup
reportGroup := codebuild.NewReportGroup(this, jsii.String("ReportGroup"))

project := codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	source: source,
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		// ...
		"reports": map[string]map[string]*string{
			reportGroup.reportGroupArn: map[string]*string{
				"files": jsii.String("**/*"),
				"base-directory": jsii.String("build/test-results"),
			},
		},
	}),
})

Experimental.

func NewReportGroup 

func NewReportGroup(scope constructs.Construct, id *string, props *ReportGroupProps) ReportGroup

Experimental.

type ReportGroupProps 

type ReportGroupProps struct {
	// An optional S3 bucket to export the reports to.
	// Experimental.
	ExportBucket awss3.IBucket `field:"optional" json:"exportBucket" yaml:"exportBucket"`
	// What to do when this resource is deleted from a stack.
	//
	// As CodeBuild does not allow deleting a ResourceGroup that has reports inside of it,
	// this is set to retain the resource by default.
	// Experimental.
	RemovalPolicy awscdk.RemovalPolicy `field:"optional" json:"removalPolicy" yaml:"removalPolicy"`
	// The physical name of the report group.
	// Experimental.
	ReportGroupName *string `field:"optional" json:"reportGroupName" yaml:"reportGroupName"`
	// Whether to output the report files into the export bucket as-is, or create a ZIP from them before doing the export.
	//
	// Ignored if {@link exportBucket} has not been provided.
	// Experimental.
	ZipExport *bool `field:"optional" json:"zipExport" yaml:"zipExport"`
}

Construction properties for {@link ReportGroup}.

Example: 

// The code below shows an example of how to instantiate this type.
// The values are placeholders you should change.
import monocdk "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

reportGroupProps := &reportGroupProps{
	exportBucket: bucket,
	removalPolicy: monocdk.removalPolicy_DESTROY,
	reportGroupName: jsii.String("reportGroupName"),
	zipExport: jsii.Boolean(false),
}

Experimental.

type S3ArtifactsProps 

type S3ArtifactsProps struct {
	// The artifact identifier.
	//
	// This property is required on secondary artifacts.
	// Experimental.
	Identifier *string `field:"optional" json:"identifier" yaml:"identifier"`
	// The name of the output bucket.
	// Experimental.
	Bucket awss3.IBucket `field:"required" json:"bucket" yaml:"bucket"`
	// If this is false, build output will not be encrypted.
	//
	// This is useful if the artifact to publish a static website or sharing content with others.
	// Experimental.
	Encryption *bool `field:"optional" json:"encryption" yaml:"encryption"`
	// Indicates if the build ID should be included in the path.
	//
	// If this is set to true,
	// then the build artifact will be stored in "<path>/<build-id>/<name>".
	// Experimental.
	IncludeBuildId *bool `field:"optional" json:"includeBuildId" yaml:"includeBuildId"`
	// The name of the build output ZIP file or folder inside the bucket.
	//
	// The full S3 object key will be "<path>/<build-id>/<name>" or
	// "<path>/<name>" depending on whether `includeBuildId` is set to true.
	//
	// If not set, `overrideArtifactName` will be set and the name from the
	// buildspec will be used instead.
	// Experimental.
	Name *string `field:"optional" json:"name" yaml:"name"`
	// If this is true, all build output will be packaged into a single .zip file. Otherwise, all files will be uploaded to <path>/<name>.
	// Experimental.
	PackageZip *bool `field:"optional" json:"packageZip" yaml:"packageZip"`
	// The path inside of the bucket for the build output .zip file or folder. If a value is not specified, then build output will be stored at the root of the bucket (or under the <build-id> directory if `includeBuildId` is set to true).
	// Experimental.
	Path *string `field:"optional" json:"path" yaml:"path"`
}

Construction properties for {@link S3Artifacts}.

Example: 

var bucket bucket

project := codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	buildSpec: codebuild.buildSpec.fromObject(map[string]interface{}{
		"version": jsii.String("0.2"),
	}),
	artifacts: codebuild.artifacts.s3(&s3ArtifactsProps{
		bucket: bucket,
		includeBuildId: jsii.Boolean(false),
		packageZip: jsii.Boolean(true),
		path: jsii.String("another/path"),
		identifier: jsii.String("AddArtifact1"),
	}),
})

Experimental.

type S3LoggingOptions 

type S3LoggingOptions struct {
	// The S3 Bucket to send logs to.
	// Experimental.
	Bucket awss3.IBucket `field:"required" json:"bucket" yaml:"bucket"`
	// The current status of the logs in Amazon CloudWatch Logs for a build project.
	// Experimental.
	Enabled *bool `field:"optional" json:"enabled" yaml:"enabled"`
	// Encrypt the S3 build log output.
	// Experimental.
	Encrypted *bool `field:"optional" json:"encrypted" yaml:"encrypted"`
	// The path prefix for S3 logs.
	// Experimental.
	Prefix *string `field:"optional" json:"prefix" yaml:"prefix"`
}

Information about logs built to an S3 bucket for a build project.

Example: 

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	logging: &loggingOptions{
		s3: &s3LoggingOptions{
			bucket: s3.NewBucket(this, jsii.String("LogBucket")),
		},
	},
})

Experimental.

type S3SourceProps 

type S3SourceProps struct {
	// The source identifier.
	//
	// This property is required on secondary sources.
	// Experimental.
	Identifier *string `field:"optional" json:"identifier" yaml:"identifier"`
	// Experimental.
	Bucket awss3.IBucket `field:"required" json:"bucket" yaml:"bucket"`
	// Experimental.
	Path *string `field:"required" json:"path" yaml:"path"`
	// The version ID of the object that represents the build input ZIP file to use.
	// Experimental.
	Version *string `field:"optional" json:"version" yaml:"version"`
}

Construction properties for {@link S3Source}.

Example: 

bucket := s3.NewBucket(this, jsii.String("MyBucket"))

codebuild.NewProject(this, jsii.String("MyProject"), &projectProps{
	source: codebuild.source.s3(&s3SourceProps{
		bucket: bucket,
		path: jsii.String("path/to/file.zip"),
	}),
})

Experimental.

type Source 

type Source interface {
	ISource
	// Experimental.
	BadgeSupported() *bool
	// Experimental.
	Identifier() *string
	// Experimental.
	Type() *string
	// Called by the project when the source is added so that the source can perform binding operations on the source.
	//
	// For example, it can grant permissions to the
	// code build project to read from the S3 bucket.
	// Experimental.
	Bind(_scope awscdk.Construct, _project IProject) *SourceConfig
}

Source provider definition for a CodeBuild Project.

Example: 

gitHubSource := codebuild.source.gitHub(&gitHubSourceProps{
	owner: jsii.String("awslabs"),
	repo: jsii.String("aws-cdk"),
	webhook: jsii.Boolean(true),
	 // optional, default: true if `webhookFilters` were provided, false otherwise
	webhookTriggersBatchBuild: jsii.Boolean(true),
	 // optional, default is false
	webhookFilters: []filterGroup{
		codebuild.*filterGroup.inEventOf(codebuild.eventAction_PUSH).andBranchIs(jsii.String("master")).andCommitMessageIs(jsii.String("the commit message")),
	},
})

Experimental.

type SourceConfig 

type SourceConfig struct {
	// Experimental.
	SourceProperty *CfnProject_SourceProperty `field:"required" json:"sourceProperty" yaml:"sourceProperty"`
	// Experimental.
	BuildTriggers *CfnProject_ProjectTriggersProperty `field:"optional" json:"buildTriggers" yaml:"buildTriggers"`
	// `AWS::CodeBuild::Project.SourceVersion`.
	// See: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-codebuild-project.html#cfn-codebuild-project-sourceversion
	//
	// Experimental.
	SourceVersion *string `field:"optional" json:"sourceVersion" yaml:"sourceVersion"`
}

The type returned from {@link ISource#bind}.

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"

sourceConfig := &sourceConfig{
	sourceProperty: &sourceProperty{
		type: jsii.String("type"),

		// the properties below are optional
		auth: &sourceAuthProperty{
			type: jsii.String("type"),

			// the properties below are optional
			resource: jsii.String("resource"),
		},
		buildSpec: jsii.String("buildSpec"),
		buildStatusConfig: &buildStatusConfigProperty{
			context: jsii.String("context"),
			targetUrl: jsii.String("targetUrl"),
		},
		gitCloneDepth: jsii.Number(123),
		gitSubmodulesConfig: &gitSubmodulesConfigProperty{
			fetchSubmodules: jsii.Boolean(false),
		},
		insecureSsl: jsii.Boolean(false),
		location: jsii.String("location"),
		reportBuildStatus: jsii.Boolean(false),
		sourceIdentifier: jsii.String("sourceIdentifier"),
	},

	// the properties below are optional
	buildTriggers: &projectTriggersProperty{
		buildType: jsii.String("buildType"),
		filterGroups: []interface{}{
			[]interface{}{
				&webhookFilterProperty{
					pattern: jsii.String("pattern"),
					type: jsii.String("type"),

					// the properties below are optional
					excludeMatchedPattern: jsii.Boolean(false),
				},
			},
		},
		webhook: jsii.Boolean(false),
	},
	sourceVersion: jsii.String("sourceVersion"),
}

Experimental.

type SourceProps 

type SourceProps struct {
	// The source identifier.
	//
	// This property is required on secondary sources.
	// Experimental.
	Identifier *string `field:"optional" json:"identifier" yaml:"identifier"`
}

Properties common to all Source classes.

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"

sourceProps := &sourceProps{
	identifier: jsii.String("identifier"),
}

Experimental.

type StateChangeEvent 

type StateChangeEvent interface {
}

Event fields for the CodeBuild "state change" event. See: https://docs.aws.amazon.com/codebuild/latest/userguide/sample-build-notifications.html#sample-build-notifications-ref

Experimental.

type UntrustedCodeBoundaryPolicy 

type UntrustedCodeBoundaryPolicy interface {
	awsiam.ManagedPolicy
	// The description of this policy.
	// Experimental.
	Description() *string
	// The policy document.
	// Experimental.
	Document() awsiam.PolicyDocument
	// 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.
	// Experimental.
	Env() *awscdk.ResourceEnvironment
	// Returns the ARN of this managed policy.
	// Experimental.
	ManagedPolicyArn() *string
	// The name of this policy.
	// Experimental.
	ManagedPolicyName() *string
	// The construct tree node associated with this construct.
	// Experimental.
	Node() awscdk.ConstructNode
	// The path of this policy.
	// Experimental.
	Path() *string
	// 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.
	// Experimental.
	PhysicalName() *string
	// The stack in which this resource is defined.
	// Experimental.
	Stack() awscdk.Stack
	// Adds a statement to the policy document.
	// Experimental.
	AddStatements(statement ...awsiam.PolicyStatement)
	// 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`).
	// Experimental.
	ApplyRemovalPolicy(policy awscdk.RemovalPolicy)
	// Attaches this policy to a group.
	// Experimental.
	AttachToGroup(group awsiam.IGroup)
	// Attaches this policy to a role.
	// Experimental.
	AttachToRole(role awsiam.IRole)
	// Attaches this policy to a user.
	// Experimental.
	AttachToUser(user awsiam.IUser)
	// Experimental.
	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`.
	// Experimental.
	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.
	// Experimental.
	GetResourceNameAttribute(nameAttr *string) *string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	OnPrepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	OnSynthesize(session constructs.ISynthesisSession)
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	//
	// Returns: An array of validation error messages, or an empty array if the construct is valid.
	// Experimental.
	OnValidate() *[]*string
	// Perform final modifications before synthesis.
	//
	// This method can be implemented by derived constructs in order to perform
	// final changes before synthesis. prepare() will be called after child
	// constructs have been prepared.
	//
	// This is an advanced framework feature. Only use this if you
	// understand the implications.
	// Experimental.
	Prepare()
	// Allows this construct to emit artifacts into the cloud assembly during synthesis.
	//
	// This method is usually implemented by framework-level constructs such as `Stack` and `Asset`
	// as they participate in synthesizing the cloud assembly.
	// Experimental.
	Synthesize(session awscdk.ISynthesisSession)
	// Returns a string representation of this construct.
	// Experimental.
	ToString() *string
	// Validate the current construct.
	//
	// This method can be implemented by derived constructs in order to perform
	// validation logic. It is called on all constructs before synthesis.
	// Experimental.
	Validate() *[]*string
}

Permissions Boundary for a CodeBuild Project running untrusted code.

This class is a Policy, intended to be used as a Permissions Boundary for a CodeBuild project. It allows most of the actions necessary to run the CodeBuild project, but disallows reading from Parameter Store and Secrets Manager.

Use this when your CodeBuild project is running untrusted code (for example, if you are using one to automatically build Pull Requests that anyone can submit), and you want to prevent your future self from accidentally exposing Secrets to this build.

(The reason you might want to do this is because otherwise anyone who can submit a Pull Request to your project can write a script to email those secrets to themselves).

Example: 

var project project

iam.permissionsBoundary.of(project).apply(codebuild.NewUntrustedCodeBoundaryPolicy(this, jsii.String("Boundary")))

Experimental.

func NewUntrustedCodeBoundaryPolicy 

func NewUntrustedCodeBoundaryPolicy(scope constructs.Construct, id *string, props *UntrustedCodeBoundaryPolicyProps) UntrustedCodeBoundaryPolicy

Experimental.

type UntrustedCodeBoundaryPolicyProps 

type UntrustedCodeBoundaryPolicyProps struct {
	// Additional statements to add to the default set of statements.
	// Experimental.
	AdditionalStatements *[]awsiam.PolicyStatement `field:"optional" json:"additionalStatements" yaml:"additionalStatements"`
	// The name of the managed policy.
	// Experimental.
	ManagedPolicyName *string `field:"optional" json:"managedPolicyName" yaml:"managedPolicyName"`
}

Construction properties for UntrustedCodeBoundaryPolicy.

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

untrustedCodeBoundaryPolicyProps := &untrustedCodeBoundaryPolicyProps{
	additionalStatements: []*policyStatement{
		policyStatement,
	},
	managedPolicyName: jsii.String("managedPolicyName"),
}

Experimental.

type WindowsBuildImage 

type WindowsBuildImage interface {
	IBuildImage
	// The default {@link ComputeType} to use with this image, if one was not specified in {@link BuildEnvironment#computeType} explicitly.
	// Experimental.
	DefaultComputeType() ComputeType
	// The Docker image identifier that the build environment uses.
	// Experimental.
	ImageId() *string
	// The type of principal that CodeBuild will use to pull this build Docker image.
	// Experimental.
	ImagePullPrincipalType() ImagePullPrincipalType
	// An optional ECR repository that the image is hosted in.
	// Experimental.
	Repository() awsecr.IRepository
	// The secretsManagerCredentials for access to a private registry.
	// Experimental.
	SecretsManagerCredentials() awssecretsmanager.ISecret
	// The type of build environment.
	// Experimental.
	Type() *string
	// Make a buildspec to run the indicated script.
	// Experimental.
	RunScriptBuildspec(entrypoint *string) BuildSpec
	// Allows the image a chance to validate whether the passed configuration is correct.
	// Experimental.
	Validate(buildEnvironment *BuildEnvironment) *[]*string
}

A CodeBuild image running Windows.

This class has a bunch of public constants that represent the most popular images.

You can also specify a custom image using one of the static methods:

- WindowsBuildImage.fromDockerRegistry(image[, { secretsManagerCredentials }, imageType]) - WindowsBuildImage.fromEcrRepository(repo[, tag, imageType]) - WindowsBuildImage.fromAsset(parent, id, props, [, imageType])

Example: 

var ecrRepository repository

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	environment: &buildEnvironment{
		buildImage: codebuild.windowsBuildImage.fromEcrRepository(ecrRepository, jsii.String("v1.0"), codebuild.windowsImageType_SERVER_2019),
		// optional certificate to include in the build image
		certificate: &buildEnvironmentCertificate{
			bucket: s3.bucket.fromBucketName(this, jsii.String("Bucket"), jsii.String("my-bucket")),
			objectKey: jsii.String("path/to/cert.pem"),
		},
	},
})

See: https://docs.aws.amazon.com/codebuild/latest/userguide/build-env-ref-available.html

Experimental.

type WindowsImageType 

type WindowsImageType string

Environment type for Windows Docker images.

Example: 

var ecrRepository repository

codebuild.NewProject(this, jsii.String("Project"), &projectProps{
	environment: &buildEnvironment{
		buildImage: codebuild.windowsBuildImage.fromEcrRepository(ecrRepository, jsii.String("v1.0"), codebuild.windowsImageType_SERVER_2019),
		// optional certificate to include in the build image
		certificate: &buildEnvironmentCertificate{
			bucket: s3.bucket.fromBucketName(this, jsii.String("Bucket"), jsii.String("my-bucket")),
			objectKey: jsii.String("path/to/cert.pem"),
		},
	},
})

Experimental. 

const (
	// The standard environment type, WINDOWS_CONTAINER.
	// Experimental.
	WindowsImageType_STANDARD WindowsImageType = "STANDARD"
	// The WINDOWS_SERVER_2019_CONTAINER environment type.
	// Experimental.
	WindowsImageType_SERVER_2019 WindowsImageType = "SERVER_2019"
)

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.