Module types

The action engine, or executor, for an action type created for a provider, where the action is to be used by customers of the provider. The action engine is associated with the model used to create and update the action, such as the Lambda integration model.

ActionTypeId

Represents information about an action type.

ActionTypeIdentifier

Specifies the category, owner, provider, and version of the action type.

ActionTypePermissions

Details identifying the users with permissions to use the action type.

ActionTypeProperty

Represents information about each property specified in the action configuration, such as the description and key name that display for the customer using the action type.

ActionTypeSettings

Returns information about the settings for an action type.

ActionTypeUrls

Returns information about URLs for web pages that display to customers as links on the pipeline view, such as an external configuration page for the action type.

ApprovalResult

Represents information about the result of an approval request.

Artifact

Artifacts are the files that are worked on by actions in the pipeline. See the action configuration for each action for details about artifact parameters. For example, the S3 source action artifact is a file name (or file path), and the files are generally provided as a ZIP file. Example artifact name: SampleApp_Windows.zip

ArtifactDetail

Artifact details for the action execution, such as the artifact location.

ArtifactDetails

Returns information about the details of an artifact.

ArtifactLocation

Represents information about the location of an artifact.

ArtifactRevision

Represents revision details of an artifact.

ArtifactStore

The S3 bucket where artifacts for the pipeline are stored.

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

AwsSessionCredentials

Represents an Amazon Web Services session credentials object. These credentials are temporary credentials that are issued by Amazon Web Services Secure Token Service (STS). They can be used to access input and output artifacts in the S3 bucket used to store artifact for the pipeline in CodePipeline.

BeforeEntryConditions

The conditions for making checks for entry to a stage. For more information about conditions, see Stage conditions and How do stage conditions work?.

BlockerDeclaration

Reserved for future use.

Condition

The condition for the stage. A condition is made up of the rules and the result for the condition. For more information about conditions, see Stage conditions and How do stage conditions work?.. For more information about rules, see the CodePipeline rule reference.

ConditionExecution

The run of a condition.

ConditionState

Information about the state of the condition.

CurrentRevision

Represents information about a current revision.

DeployActionExecutionTarget

The target for the deploy action.

DeployTargetEvent

A lifecycle event for the deploy action.

DeployTargetEventContext

The context for the event for the deploy action.

EncryptionKey

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

EnvironmentVariable

The environment variables for the action.

ErrorDetails

Represents information about an error in CodePipeline.

ExecutionDetails

The details of the actions taken and results produced on an artifact as it passes through stages in the pipeline.

ExecutionTrigger

The interaction or event that started a pipeline execution.

ExecutorConfiguration

The action engine, or executor, related to the supported integration model used to create and update the action type. The available executor types are Lambda and JobWorker.

FailureConditions

The configuration that specifies the result, such as rollback, to occur upon stage failure. For more information about conditions, see Stage conditions and How do stage conditions work?.

FailureDetails

Represents information about failure details.

GitBranchFilterCriteria

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

GitConfiguration

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

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

GitFilePathFilterCriteria

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

GitPullRequestFilter

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

The following are valid values for the events for this filter:

CLOSED
OPEN
UPDATED

GitPushFilter

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

GitTagFilterCriteria

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

InputArtifact

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

Job

Represents information about a job.

JobData

Represents other information about a job required for a job worker to complete the job.

JobDetails

Represents information about the details of a job.

JobWorkerExecutorConfiguration

Details about the polling configuration for the JobWorker action engine, or executor.

LambdaExecutorConfiguration

Details about the configuration for the Lambda action engine, or executor.

LatestInPipelineExecutionFilter

The field that specifies to filter on the latest execution in the pipeline.

Filtering on the latest execution is available for executions run on or after February 08, 2024.

ListWebhookItem

The detail returned for each webhook after listing webhooks, such as the webhook URL, the webhook name, and the webhook ARN.

OutputArtifact

Represents information about the output of an action.

PipelineContext

Represents information about a pipeline to a job worker.

PipelineContext contains pipelineArn and pipelineExecutionId for custom action jobs. The pipelineArn and pipelineExecutionId fields are not populated for ThirdParty action jobs.

PipelineDeclaration

Represents the structure of actions and stages to be performed in the pipeline.

PipelineExecution

Represents information about an execution of a pipeline.

PipelineExecutionFilter

The pipeline execution to filter on.

PipelineExecutionSummary

Summary information about a pipeline execution.

PipelineMetadata

Information about a pipeline.

PipelineRollbackMetadata

The metadata for the stage execution to be rolled back.

PipelineSummary

Returns a summary of a pipeline.

PipelineTriggerDeclaration

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

This is only supported for the CodeStarSourceConnection action type.

When a trigger configuration is specified, default change detection for repository and branch commits is disabled.

PipelineVariable

A pipeline-level variable used for a pipeline execution.

PipelineVariableDeclaration

A variable declared at the pipeline level.

ResolvedPipelineVariable

A pipeline-level variable used for a pipeline execution.

RetryConfiguration

The retry configuration specifies automatic retry for a failed stage, along with the configured retry mode.

RetryStageMetadata

The details of a specific automatic retry on stage failure, including the attempt number and trigger.

RuleConfigurationProperty

Represents information about a rule configuration property.

RuleDeclaration

Represents information about the rule to be created for an associated condition. An example would be creating a new rule for an entry condition, such as a rule that checks for a test result before allowing the run to enter the deployment stage. For more information about conditions, see Stage conditions and How do stage conditions work?. For more information about rules, see the CodePipeline rule reference.

RuleExecution

Represents information about each time a rule is run as part of the pipeline execution for a pipeline configured with conditions.

RuleExecutionDetail

The details of the runs for a rule and the results produced on an artifact as it passes through stages in the pipeline.

RuleExecutionFilter

Filter values for the rule execution.

RuleExecutionInput

Input information used for a rule execution.

RuleExecutionOutput

Output details listed for a rule execution, such as the rule execution result.

RuleExecutionResult

Execution result information, such as the external execution ID.

RuleRevision

The change to a rule that creates a revision of the rule.

RuleState

Returns information about the state of a rule.

Values returned in the revisionId field indicate the rule revision information, such as the commit ID, for the current state.

RuleType

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

RuleTypeId

The ID for the rule type, which is made up of the combined values for category, owner, provider, and version. For more information about conditions, see Stage conditions. For more information about rules, see the CodePipeline rule reference.

RuleTypeSettings

Returns information about the settings for a rule type.

S3ArtifactLocation

The location of the S3 bucket that contains a revision.

S3Location

The Amazon S3 artifact location for an action's artifacts.

SourceRevision

Information about the version (or revision) of a source artifact that initiated a pipeline execution.

SourceRevisionOverride

A list that allows you to specify, or override, the source revision for a pipeline execution that's being started. A source revision is the version with all the changes to your application code, or source artifact, for the pipeline execution.

For the S3_OBJECT_VERSION_ID and S3_OBJECT_KEY types of source revisions, either of the types can be used independently, or they can be used together to override the source with a specific ObjectKey and VersionID.

StageConditionState

The state of a run of a condition for a stage.

StageConditionsExecution

Represents information about the run of a condition for a stage.

StageContext

Represents information about a stage to a job worker.

StageDeclaration

Represents information about a stage and its definition.

StageExecution

Represents information about the run of a stage.

StageState

Represents information about the state of the stage.

StopExecutionTrigger

The interaction that stopped a pipeline execution.

SucceededInStageFilter

Filter for pipeline executions that have successfully completed the stage in the current pipeline version.

SuccessConditions

The conditions for making checks that, if met, succeed a stage. For more information about conditions, see Stage conditions and How do stage conditions work?.

Tag

A tag is a key-value pair that is used to manage the resource.

TargetFilter

Filters the list of targets.

ThirdPartyJob

A response to a PollForThirdPartyJobs request returned by CodePipeline when there is a job to be worked on by a partner action.

ThirdPartyJobData

Represents information about the job data for a partner action.

ThirdPartyJobDetails

The details of a job sent in response to a GetThirdPartyJobDetails request.

TransitionState

Represents information about the state of transitions between one stage and another stage.

WebhookAuthConfiguration

The authentication applied to incoming webhook trigger requests.

WebhookDefinition

Represents information about a webhook and its definition.

WebhookFilterRule

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

Enums§

ActionCategory: When writing a match expression against ActionCategory, 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.
ActionConfigurationPropertyType: When writing a match expression against ActionConfigurationPropertyType, 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.
ActionExecutionStatus: When writing a match expression against ActionExecutionStatus, 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.
ActionOwner: When writing a match expression against ActionOwner, 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.
ApprovalStatus: When writing a match expression against ApprovalStatus, 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.
ArtifactLocationType: When writing a match expression against ArtifactLocationType, 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.
ArtifactStoreType: When writing a match expression against ArtifactStoreType, 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.
BlockerType: When writing a match expression against BlockerType, 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.
ConditionExecutionStatus: When writing a match expression against ConditionExecutionStatus, 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.
ConditionType: When writing a match expression against ConditionType, 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.
EncryptionKeyType: When writing a match expression against EncryptionKeyType, 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.
ExecutionMode: When writing a match expression against ExecutionMode, 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.
ExecutionType: When writing a match expression against ExecutionType, 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.
ExecutorType: When writing a match expression against ExecutorType, 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.
FailureType: When writing a match expression against FailureType, 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.
GitPullRequestEventType: When writing a match expression against GitPullRequestEventType, 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.
JobStatus: When writing a match expression against JobStatus, 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.
PipelineExecutionStatus: When writing a match expression against PipelineExecutionStatus, 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.
PipelineTriggerProviderType: When writing a match expression against PipelineTriggerProviderType, 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.
PipelineType: When writing a match expression against PipelineType, 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.
Result: When writing a match expression against Result, 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.
RetryTrigger: When writing a match expression against RetryTrigger, 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.
RuleCategory: When writing a match expression against RuleCategory, 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.
RuleConfigurationPropertyType: When writing a match expression against RuleConfigurationPropertyType, 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.
RuleExecutionStatus: When writing a match expression against RuleExecutionStatus, 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.
RuleOwner: When writing a match expression against RuleOwner, 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.
SourceRevisionType: When writing a match expression against SourceRevisionType, 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.
StageExecutionStatus: When writing a match expression against StageExecutionStatus, 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.
StageRetryMode: When writing a match expression against StageRetryMode, 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.
StageTransitionType: When writing a match expression against StageTransitionType, 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.
StartTimeRange: When writing a match expression against StartTimeRange, 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.
TargetFilterName: When writing a match expression against TargetFilterName, 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.
TriggerType: When writing a match expression against TriggerType, 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.
WebhookAuthenticationType: When writing a match expression against WebhookAuthenticationType, 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