Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that ARC - Region switch can respond with.

Structs

AbbreviatedExecution

A summarized representation of a plan execution. This structure contains key information about an execution without all the detailed step data.

AbbreviatedPlan

A summarized representation of a Region switch plan. This structure contains key information about a plan without all the detailed workflow and step data.

ArcRoutingControlConfiguration

Configuration for ARC routing controls used in a Region switch plan. Routing controls are simple on/off switches that you can use to shift traffic away from an impaired Region.

ArcRoutingControlState

Represents the state of an ARC routing control.

Asg

Configuration for an Amazon EC2 Auto Scaling group used in a Region switch plan.

AssociatedAlarm

An Amazon CloudWatch alarm associated with a Region switch plan. These alarms can be used to trigger automatic execution of the plan.

CustomActionLambdaConfiguration

Configuration for Amazon Web Services Lambda functions that perform custom actions during a Region switch.

Ec2AsgCapacityIncreaseConfiguration

Configuration for increasing the capacity of Amazon EC2 Auto Scaling groups during a Region switch.

Ec2Ungraceful

Configuration for handling failures when performing operations on EC2 resources.

EcsCapacityIncreaseConfiguration

The configuration for an Amazon Web Services ECS capacity increase.

EcsUngraceful

The settings for ungraceful execution.

EksCluster

The Amazon Web Services EKS cluster execution block configuration.

EksResourceScalingConfiguration

The Amazon Web Services EKS resource scaling configuration.

EksResourceScalingUngraceful

The ungraceful settings for Amazon Web Services EKS resource scaling.

ExecutionApprovalConfiguration

Configuration for approval steps in a Region switch plan execution. Approval steps require manual intervention before the execution can proceed.

ExecutionEvent

Represents an event that occurred during a plan execution. These events provide a detailed timeline of the execution process.

GlobalAuroraConfiguration

Configuration for Amazon Aurora global databases used in a Region switch plan.

GlobalAuroraUngraceful

Configuration for handling failures when performing operations on Aurora global databases.

KubernetesResourceType

Defines the type of Kubernetes resource to scale in an Amazon EKS cluster.

KubernetesScalingResource

Defines a Kubernetes resource to scale in an Amazon EKS cluster.

LambdaUngraceful

Configuration for handling failures when invoking Lambda functions.

Lambdas

Configuration for Amazon Web Services Lambda functions used in a Region switch plan.

MinimalWorkflow

A simplified representation of a workflow in a Region switch plan.

ParallelExecutionBlockConfiguration

Configuration for steps that should be executed in parallel during a Region switch.

Plan

Represents a Region switch plan. A plan defines the steps required to shift traffic from one Amazon Web Services Region to another.

RegionSwitchPlanConfiguration

Configuration for nested Region switch plans. This allows one Region switch plan to trigger another plan as part of its execution.

ResourceWarning

Represents a warning about a resource in a Region switch plan.

Route53HealthCheck

The Amazon Route 53 health check.

Route53HealthCheckConfiguration

The Amazon Route 53 health check configuration.

Route53ResourceRecordSet

The Amazon Route 53 record set.

Service

The service for a cross account role.

Step

Represents a step in a Region switch plan workflow. Each step performs a specific action during the Region switch process.

StepState

Represents the state of a step in a plan execution.

Trigger

Defines a condition that can automatically trigger the execution of a Region switch plan.

TriggerCondition

Defines a condition that must be met for a trigger to fire.

Workflow

Represents a workflow in a Region switch plan. A workflow defines a sequence of steps to execute during a Region switch.

Enums

AlarmCondition

When writing a match expression against AlarmCondition, 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.

AlarmType

When writing a match expression against AlarmType, 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.

Approval

When writing a match expression against Approval, 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.

Ec2AsgCapacityMonitoringApproach

When writing a match expression against Ec2AsgCapacityMonitoringApproach, 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.

EcsCapacityMonitoringApproach

When writing a match expression against EcsCapacityMonitoringApproach, 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.

EksCapacityMonitoringApproach

When writing a match expression against EksCapacityMonitoringApproach, 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.

EvaluationStatus

When writing a match expression against EvaluationStatus, 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.

ExecutionAction

When writing a match expression against ExecutionAction, 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.

ExecutionBlockConfiguration

Execution block configurations for a workflow in a Region switch plan. An execution block represents a specific type of action to perform during a Region switch.

ExecutionBlockType

When writing a match expression against ExecutionBlockType, 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.

ExecutionEventType

When writing a match expression against ExecutionEventType, 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.

ExecutionState

When writing a match expression against ExecutionState, 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.

GlobalAuroraDefaultBehavior

When writing a match expression against GlobalAuroraDefaultBehavior, 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.

GlobalAuroraUngracefulBehavior

When writing a match expression against GlobalAuroraUngracefulBehavior, 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.

LambdaUngracefulBehavior

When writing a match expression against LambdaUngracefulBehavior, 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.

RecoveryApproach

When writing a match expression against RecoveryApproach, 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.

RegionToRunIn

When writing a match expression against RegionToRunIn, 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.

ResourceWarningStatus

When writing a match expression against ResourceWarningStatus, 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.

RoutingControlStateChange

When writing a match expression against RoutingControlStateChange, 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.

StepStatus

When writing a match expression against StepStatus, 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.

UpdatePlanExecutionAction

When writing a match expression against UpdatePlanExecutionAction, 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.

UpdatePlanExecutionStepAction

When writing a match expression against UpdatePlanExecutionStepAction, 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.

WorkflowTargetAction

When writing a match expression against WorkflowTargetAction, 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.