Module types

Data structures used by operation inputs/outputs.

Modules

• builders
  Builders
• error
  Error types that AWS CodeBuild can respond with.

Structs

• AutoRetryConfig

  Information about the auto-retry configuration for the build.

• BatchRestrictions

  Specifies restrictions for the batch build.

• Build

  Information about a build.

• BuildArtifacts

  Information about build output artifacts.

• BuildBatch

  Contains information about a batch build.

• BuildBatchFilter

  Specifies filters when retrieving batch builds.

• BuildBatchPhase

  Contains information about a stage for a batch build.

• BuildGroup

  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.

• ComputeConfiguration

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

• DebugSession

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

• 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.

• 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.

• 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.
• 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.