Module types 

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that Elastic Disaster Recovery Service can respond with.

Structs

Account

AWS account.

ConversionProperties

Properties of a conversion job

Cpu

Information about a server's CPU.

DataReplicationError

Error in data replication.

DataReplicationInfo

Information about Data Replication

DataReplicationInfoReplicatedDisk

A disk that should be replicated.

DataReplicationInitiation

Data replication initiation.

DataReplicationInitiationStep

Data replication initiation step.

DescribeJobsRequestFilters

A set of filters by which to return Jobs.

DescribeRecoveryInstancesRequestFilters

A set of filters by which to return Recovery Instances.

DescribeRecoverySnapshotsRequestFilters

A set of filters by which to return Recovery Snapshots.

DescribeSourceNetworksRequestFilters

A set of filters by which to return Source Networks.

DescribeSourceServersRequestFilters

A set of filters by which to return Source Servers.

Disk

An object representing a data storage device on a server.

IdentificationHints

Hints used to uniquely identify a machine.

Job

A job is an asynchronous workflow.

JobLog

A log outputted by a Job.

JobLogEventData

Metadata associated with a Job log.

LaunchAction

Launch action.

LaunchActionParameter

Launch action parameter.

LaunchActionRun

Launch action run.

LaunchActionsRequestFilters

Resource launch actions filter.

LaunchActionsStatus

Launch actions status.

LaunchConfigurationTemplate

Account level Launch Configuration Template.

LaunchIntoInstanceProperties

Launch into existing instance.

Licensing

Configuration of a machine's license.

LifeCycle

An object representing the Source Server Lifecycle.

LifeCycleLastLaunch

An object containing information regarding the last launch of a Source Server.

LifeCycleLastLaunchInitiated

An object containing information regarding the initiation of the last launch of a Source Server.

NetworkInterface

Network interface.

Os

Operating System.

ParticipatingResource

Represents a resource participating in an asynchronous Job.

ParticipatingServer

Represents a server participating in an asynchronous Job.

PitPolicyRule

A rule in the Point in Time (PIT) policy representing when to take snapshots and how long to retain them for.

ProductCode

Properties of a product code associated with a volume.

RecoveryInstance

A Recovery Instance is a replica of a Source Server running on EC2.

RecoveryInstanceDataReplicationError

Error in data replication.

RecoveryInstanceDataReplicationInfo

Information about Data Replication

RecoveryInstanceDataReplicationInfoReplicatedDisk

A disk that should be replicated.

RecoveryInstanceDataReplicationInitiation

Data replication initiation.

RecoveryInstanceDataReplicationInitiationStep

Data replication initiation step.

RecoveryInstanceDisk

An object representing a block storage device on the Recovery Instance.

RecoveryInstanceFailback

An object representing failback related information of the Recovery Instance.

RecoveryInstanceProperties

Properties of the Recovery Instance machine.

RecoveryLifeCycle

An object representing the Source Network recovery Lifecycle.

RecoverySnapshot

A snapshot of a Source Server used during recovery.

ReplicationConfigurationReplicatedDisk

The configuration of a disk of the Source Server to be replicated.

ReplicationConfigurationTemplate

SourceCloudProperties

Properties of the cloud environment where this Source Server originated from.

SourceNetwork

The ARN of the Source Network.

SourceNetworkData

Properties of Source Network related to a job event.

SourceProperties

Properties of the Source Server machine.

SourceServer

StagingArea

Staging information related to source server.

StagingSourceServer

Source server in staging account that extended source server connected to.

StartRecoveryRequestSourceServer

An object representing the Source Server to recover.

StartSourceNetworkRecoveryRequestNetworkEntry

An object representing the Source Network to recover.

ValidationExceptionField

Validate exception field.

Enums

DataReplicationErrorString

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

DataReplicationInitiationStepName

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

DataReplicationInitiationStepStatus

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

DataReplicationState

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

Ec2InstanceState

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

EventResourceData

Properties of resource related to a job event.

ExtensionStatus

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

FailbackLaunchType

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

FailbackReplicationError

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

FailbackState

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

InitiatedBy

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

JobLogEvent

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

JobType

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

LastLaunchResult

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

LastLaunchType

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

LaunchActionCategory

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

LaunchActionParameterType

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

LaunchActionRunStatus

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

LaunchActionType

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

LaunchDisposition

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

LaunchStatus

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

OriginEnvironment

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

ParticipatingResourceId

ID of a resource participating in an asynchronous Job.

PitPolicyRuleUnits

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

ProductCodeMode

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

RecoveryInstanceDataReplicationInitiationStepName

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

RecoveryInstanceDataReplicationInitiationStepStatus

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

RecoveryInstanceDataReplicationState

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

RecoveryResult

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

RecoverySnapshotsOrder

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

ReplicationConfigurationDataPlaneRouting

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

ReplicationConfigurationDefaultLargeStagingDiskType

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

ReplicationConfigurationEbsEncryption

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

ReplicationConfigurationReplicatedDiskStagingDiskType

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

ReplicationDirection

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

ReplicationStatus

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

TargetInstanceTypeRightSizingMethod

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

ValidationExceptionReason

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

VolumeStatus

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