Module types

Contains information about a batch build build group. Build groups are used to combine builds that can run in parallel, while still being able to set dependencies on other build groups.

BuildNotDeleted

Information about a build that could not be successfully deleted.

BuildPhase

Information about a stage for a build.

BuildStatusConfig

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

BuildSummary

Contains summary information about a batch build group.

CloudWatchLogsConfig

Information about CloudWatch Logs for a build project.

CodeCoverage

Contains code coverage report information.

Line coverage measures how many statements your tests cover. A statement is a single instruction, not including comments, conditionals, etc.

Branch coverage determines if your tests cover every possible branch of a control structure, such as an if or case statement.

CodeCoverageReportSummary

Contains a summary of a code coverage report.

Line coverage measures how many statements your tests cover. A statement is a single instruction, not including comments, conditionals, etc.

Branch coverage determines if your tests cover every possible branch of a control structure, such as an if or case statement.

CommandExecution

Contains command execution information.

ComputeConfiguration

Contains compute attributes. These attributes only need be specified when your project's or fleet's computeType is set to ATTRIBUTE_BASED_COMPUTE or CUSTOM_INSTANCE_TYPE.

DebugSession

Contains information about the debug session for a build. For more information, see Viewing a running build in Session Manager.

DockerServer

Contains docker server information.

DockerServerStatus

Contains information about the status of the docker server.

EnvironmentImage

Information about a Docker image that is managed by CodeBuild.

EnvironmentLanguage

A set of Docker images that are related by programming language and are managed by CodeBuild.

EnvironmentPlatform

A set of Docker images that are related by platform and are managed by CodeBuild.

EnvironmentVariable

Information about an environment variable for a build project or a build.

ExportedEnvironmentVariable

Contains information about an exported environment variable.

Exported environment variables are used in conjunction with CodePipeline to export environment variables from the current build stage to subsequent stages in the pipeline. For more information, see Working with variables in the CodePipeline User Guide.

During a build, the value of a variable is available starting with the install phase. It can be updated between the start of the install phase and the end of the post_build phase. After the post_build phase ends, the value of exported variables cannot change.

Fleet

A set of dedicated instances for your build environment.

FleetProxyRule

Information about the proxy rule for your reserved capacity instances.

FleetStatus

The status of the compute fleet.

GitSubmodulesConfig

Information about the Git submodules configuration for an CodeBuild build project.

LogsConfig

Information about logs for a build project. These can be logs in CloudWatch Logs, built in a specified S3 bucket, or both.

LogsLocation

Information about build logs in CloudWatch Logs.

NetworkInterface

Describes a network interface.

PhaseContext

Additional information about a build phase that has an error. You can use this information for troubleshooting.

Project

Information about a build project.

ProjectArtifacts

Information about the build output artifacts for the build project.

ProjectBadge

Information about the build badge for the build project.

ProjectBuildBatchConfig

Contains configuration information about a batch build project.

ProjectCache

Information about the cache for the build project.

ProjectEnvironment

Information about the build environment of the build project.

ProjectFileSystemLocation

Information about a file system created by Amazon Elastic File System (EFS). For more information, see What Is Amazon Elastic File System?

ProjectFleet

Information about the compute fleet of the build project. For more information, see Working with reserved capacity in CodeBuild.

ProjectSource

Information about the build input source code for the build project.

ProjectSourceVersion

A source identifier and its corresponding version.

ProxyConfiguration

Information about the proxy configurations that apply network access control to your reserved capacity instances.

RegistryCredential

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 Secrets Manager Sample for CodeBuild.

Report

Information about the results from running a series of test cases during the run of a build project. The test cases are specified in the buildspec for the build project using one or more paths to the test case files. You can specify any type of tests you want, such as unit tests, integration tests, and functional tests.

ReportExportConfig

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

ReportFilter

A filter used to return reports with the status specified by the input status parameter.

ReportGroup

A series of reports. Each report contains information about the results from running a series of test cases. You specify the test cases for a report group in the buildspec for a build project using one or more paths to the test case files.

ReportGroupTrendStats

Contains trend statistics for a set of reports. The actual values depend on the type of trend being collected. For more information, see .

ReportWithRawData

Contains the unmodified data for the report. For more information, see .

ResolvedArtifact

Represents a resolved build artifact. A resolved artifact is an artifact that is built and deployed to the destination, such as Amazon S3.

S3LogsConfig

Information about S3 logs for a build project.

S3ReportExportConfig

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

Sandbox

Contains sandbox information.

SandboxSession

Contains information about the sandbox session.

SandboxSessionPhase

Contains information about the sandbox phase.

ScalingConfigurationInput

The scaling configuration input of a compute fleet.

ScalingConfigurationOutput

The scaling configuration output of a compute fleet.

ScopeConfiguration

Contains configuration information about the scope for a webhook.

SourceAuth

Information about the authorization settings for CodeBuild to access the source code to be built.

SourceCredentialsInfo

Information about the credentials for a GitHub, GitHub Enterprise, GitLab, GitLab Self Managed, or Bitbucket repository.

SsmSession

Contains information about the Session Manager session.

Tag

A tag, consisting of a key and a value.

This tag is available for use by Amazon Web Services services that support tags in CodeBuild.

TargetTrackingScalingConfiguration

Defines when a new instance is auto-scaled into the compute fleet.

TestCase

Information about a test case created using a framework such as NUnit or Cucumber. A test case might be a unit test or a configuration test.

TestCaseFilter

A filter used to return specific types of test cases. In order to pass the filter, the report must meet all of the filter properties.

TestReportSummary

Information about a test report.

VpcConfig

Information about the VPC configuration that CodeBuild accesses.

Webhook

Information about a webhook that connects repository events to a build project in CodeBuild.

WebhookFilter

A filter used to determine which webhooks trigger a build.

Enums§

ArtifactNamespace: When writing a match expression against ArtifactNamespace, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ArtifactPackaging: When writing a match expression against ArtifactPackaging, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ArtifactsType: When writing a match expression against ArtifactsType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
AuthType: When writing a match expression against AuthType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
BatchReportModeType: When writing a match expression against BatchReportModeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
BucketOwnerAccess: When writing a match expression against BucketOwnerAccess, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
BuildBatchPhaseType: When writing a match expression against BuildBatchPhaseType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
BuildPhaseType: When writing a match expression against BuildPhaseType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CacheMode: When writing a match expression against CacheMode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CacheType: When writing a match expression against CacheType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CommandType: When writing a match expression against CommandType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ComputeType: When writing a match expression against ComputeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
CredentialProviderType: When writing a match expression against CredentialProviderType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
EnvironmentType: When writing a match expression against EnvironmentType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
EnvironmentVariableType: When writing a match expression against EnvironmentVariableType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FileSystemType: When writing a match expression against FileSystemType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetContextCode: When writing a match expression against FleetContextCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetOverflowBehavior: When writing a match expression against FleetOverflowBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetProxyRuleBehavior: When writing a match expression against FleetProxyRuleBehavior, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetProxyRuleEffectType: When writing a match expression against FleetProxyRuleEffectType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetProxyRuleType: When writing a match expression against FleetProxyRuleType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetScalingMetricType: When writing a match expression against FleetScalingMetricType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetScalingType: When writing a match expression against FleetScalingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetSortByType: When writing a match expression against FleetSortByType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
FleetStatusCode: When writing a match expression against FleetStatusCode, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ImagePullCredentialsType: When writing a match expression against ImagePullCredentialsType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LanguageType: When writing a match expression against LanguageType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
LogsConfigStatusType: When writing a match expression against LogsConfigStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
MachineType: When writing a match expression against MachineType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
PlatformType: When writing a match expression against PlatformType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ProjectSortByType: When writing a match expression against ProjectSortByType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ProjectVisibilityType: When writing a match expression against ProjectVisibilityType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportCodeCoverageSortByType: When writing a match expression against ReportCodeCoverageSortByType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportExportConfigType: When writing a match expression against ReportExportConfigType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportGroupSortByType: When writing a match expression against ReportGroupSortByType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportGroupStatusType: When writing a match expression against ReportGroupStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportGroupTrendFieldType: When writing a match expression against ReportGroupTrendFieldType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportPackagingType: When writing a match expression against ReportPackagingType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportStatusType: When writing a match expression against ReportStatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ReportType: When writing a match expression against ReportType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
RetryBuildBatchType: When writing a match expression against RetryBuildBatchType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
ServerType: When writing a match expression against ServerType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SharedResourceSortByType: When writing a match expression against SharedResourceSortByType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SortOrderType: When writing a match expression against SortOrderType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SourceAuthType: When writing a match expression against SourceAuthType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
SourceType: When writing a match expression against SourceType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
StatusType: When writing a match expression against StatusType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
WebhookBuildType: When writing a match expression against WebhookBuildType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
WebhookFilterType: When writing a match expression against WebhookFilterType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
WebhookScopeType: When writing a match expression against WebhookScopeType, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.
WebhookStatus: When writing a match expression against WebhookStatus, it is important to ensure your code is forward-compatible. That is, if a match arm handles a case for a feature that is supported by the service but has not been represented as an enum variant in a current version of SDK, your code should continue to work when you upgrade SDK to a future version in which the enum does include a variant for that feature.

Module typesCopy item path

Modules§

Structs§

Enums§

Module types