Module types

Data structures used by operation inputs/outputs.

Modules

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

Structs

• ActionConfiguration

  Represents information about an action configuration.

• ActionConfigurationProperty

  Represents information about an action configuration property.

• ActionContext

  Represents the context of an action in the stage of a pipeline to a job worker.

• ActionDeclaration

  Represents information about an action declaration.

• ActionExecution

  Represents information about the run of an action.

• ActionExecutionDetail

  Returns information about an execution of an action, including the action execution ID, and the name, version, and timing of the action.

• ActionExecutionFilter

  Filter values for the action execution.

• ActionExecutionInput

  Input information used for an action execution.

• ActionExecutionOutput

  Output details listed for an action execution, such as the action execution result.

• ActionExecutionResult

  Execution result information, such as the external execution ID.

• ActionRevision

  Represents information about the version (or revision) of an action.

• ActionState

  Represents information about the state of an action.

• ActionType

  Returns information about the details of an action type.

• ActionTypeArtifactDetails

  Information about parameters for artifacts associated with the action type, such as the minimum and maximum artifacts allowed.

• ActionTypeDeclaration

  The parameters for the action type definition that are provided when the action type is created or updated.

• ActionTypeExecutor

  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.

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

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

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

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

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

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

• Tag

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

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