Module types

Data structures used by operation inputs/outputs.

Modules

builders

Builders

error

Error types that AWS DataSync can respond with.

Structs

AgentListEntry

Represents a single entry in a list (or array) of DataSync agents when you call the ListAgents operation.

AzureBlobSasConfiguration

The shared access signature (SAS) configuration that allows DataSync to access your Microsoft Azure Blob Storage.

For more information, see SAS tokens for accessing your Azure Blob Storage.

Capacity

The storage capacity of an on-premises storage system resource (for example, a volume).

Credentials

The credentials that provide DataSync Discovery read access to your on-premises storage system's management interface.

DataSync Discovery stores these credentials in Secrets Manager. For more information, see Accessing your on-premises storage system.

DiscoveryJobListEntry

The details about a specific DataSync discovery job.

DiscoveryServerConfiguration

The network settings that DataSync Discovery uses to connect with your on-premises storage system's management interface.

Ec2Config

The subnet and security groups that DataSync uses to connect to one of your Amazon EFS file system's mount targets.

FilterRule

Specifies which files, folders, and objects to include or exclude when transferring files from source to destination.

FsxProtocol

Specifies the data transfer protocol that DataSync uses to access your Amazon FSx file system.

FsxProtocolNfs

Specifies the Network File System (NFS) protocol configuration that DataSync uses to access your FSx for OpenZFS file system or FSx for ONTAP file system's storage virtual machine (SVM).

FsxProtocolSmb

Specifies the Server Message Block (SMB) protocol configuration that DataSync uses to access your Amazon FSx for NetApp ONTAP file system's storage virtual machine (SVM). For more information, see Providing DataSync access to FSx for ONTAP file systems.

FsxUpdateProtocol

Specifies the data transfer protocol that DataSync uses to access your Amazon FSx file system.

You can't update the Network File System (NFS) protocol configuration for FSx for ONTAP locations. DataSync currently only supports NFS version 3 with this location type.

FsxUpdateProtocolSmb

Specifies the Server Message Block (SMB) protocol configuration that DataSync uses to access your Amazon FSx for NetApp ONTAP file system's storage virtual machine (SVM). For more information, see Providing DataSync access to FSx for ONTAP file systems.

HdfsNameNode

The NameNode of the Hadoop Distributed File System (HDFS). The NameNode manages the file system's namespace. The NameNode performs operations such as opening, closing, and renaming files and directories. The NameNode contains the information to map blocks of data to the DataNodes.

Iops

The IOPS peaks for an on-premises storage system resource. Each data point represents the 95th percentile peak value during a 1-hour interval.

Latency

The latency peaks for an on-premises storage system resource. Each data point represents the 95th percentile peak value during a 1-hour interval.

LocationFilter

Narrow down the list of resources returned by ListLocations. For example, to see all your Amazon S3 locations, create a filter using "Name": "LocationType", "Operator": "Equals", and "Values": "S3".

For more information, see filtering resources.

LocationListEntry

Represents a single entry in a list of locations. LocationListEntry returns an array that contains a list of locations when the ListLocations operation is called.

ManifestConfig

Configures a manifest, which is a list of files or objects that you want DataSync to transfer. For more information and configuration examples, see Specifying what DataSync transfers by using a manifest.

MaxP95Performance

The performance data that DataSync Discovery collects about an on-premises storage system resource.

NetAppOntapCluster

The information that DataSync Discovery collects about an on-premises storage system cluster.

NetAppOntapVolume

The information that DataSync Discovery collects about a volume in your on-premises storage system.

NetAppOntapsvm

The information that DataSync Discovery collects about a storage virtual machine (SVM) in your on-premises storage system.

NfsMountOptions

Specifies how DataSync can access a location using the NFS protocol.

OnPremConfig

The DataSync agents that can connect to your Network File System (NFS) file server.

Options

Indicates how your transfer task is configured. These options include how DataSync handles files, objects, and their associated metadata during your transfer. You also can specify how to verify data integrity, set bandwidth limits for your task, among other options.

Each option has a default value. Unless you need to, you don't have to configure any option before calling StartTaskExecution.

You also can override your task options for each task execution. For example, you might want to adjust the LogLevel for an individual execution.

P95Metrics

The types of performance data that DataSync Discovery collects about an on-premises storage system resource.

Platform

The platform-related details about the DataSync agent, such as the version number.

PrivateLinkConfig

Specifies how your DataSync agent connects to Amazon Web Services using a virtual private cloud (VPC) service endpoint. An agent that uses a VPC endpoint isn't accessible over the public internet.

QopConfiguration

The Quality of Protection (QOP) configuration specifies the Remote Procedure Call (RPC) and data transfer privacy settings configured on the Hadoop Distributed File System (HDFS) cluster.

Recommendation

The details about an Amazon Web Services storage service that DataSync Discovery recommends for a resource in your on-premises storage system.

For more information, see Recommendations provided by DataSync Discovery.

ReportDestination

Specifies where DataSync uploads your task report.

ReportDestinationS3

Specifies the Amazon S3 bucket where DataSync uploads your task report.

ReportOverride

Specifies the level of detail for a particular aspect of your DataSync task report.

ReportOverrides

The level of detail included in each aspect of your DataSync task report.

ReportResult

Indicates whether DataSync created a complete task report for your transfer.

ResourceDetails

Information provided by DataSync Discovery about the resources in your on-premises storage system.

ResourceMetrics

Information, including performance data and capacity usage, provided by DataSync Discovery about a resource in your on-premises storage system.

S3Config

Specifies the Amazon Resource Name (ARN) of the Identity and Access Management (IAM) role that DataSync uses to access your S3 bucket.

For more information, see Providing DataSync access to S3 buckets.

S3ManifestConfig

Specifies the S3 bucket where you're hosting the manifest that you want DataSync to use. For more information and configuration examples, see Specifying what DataSync transfers by using a manifest.

SmbMountOptions

Specifies the version of the Server Message Block (SMB) protocol that DataSync uses to access an SMB file server.

SourceManifestConfig

Specifies the manifest that you want DataSync to use and where it's hosted. For more information and configuration examples, see Specifying what DataSync transfers by using a manifest.

StorageSystemListEntry

Information that identifies an on-premises storage system that you're using with DataSync Discovery.

TagListEntry

A key-value pair representing a single tag that's been applied to an Amazon Web Services resource.

TaskExecutionFilesFailedDetail

The number of objects that DataSync fails to prepare, transfer, verify, and delete during your task execution.

Applies only to Enhanced mode tasks.

TaskExecutionFilesListedDetail

The number of objects that DataSync finds at your locations.

Applies only to Enhanced mode tasks.

TaskExecutionListEntry

Represents a single entry in a list of DataSync task executions that's returned with the ListTaskExecutions operation.

TaskExecutionResultDetail

Provides detailed information about the result of your DataSync task execution.

TaskFilter

You can use API filters to narrow down the list of resources returned by ListTasks. For example, to retrieve all tasks on a source location, you can use ListTasks with filter name LocationId and Operator Equals with the ARN for the location.

For more information, see filtering DataSync resources.

TaskListEntry

Represents a single entry in a list of tasks. TaskListEntry returns an array that contains a list of tasks when the ListTasks operation is called. A task includes the source and destination file systems to sync and the options to use for the tasks.

TaskReportConfig

Specifies how you want to configure a task report, which provides detailed information about for your DataSync transfer.

For more information, see Task reports.

TaskSchedule

Configures your DataSync task to run on a schedule (at a minimum interval of 1 hour).

TaskScheduleDetails

Provides information about your DataSync task schedule.

Throughput

The throughput peaks for an on-premises storage system volume. Each data point represents the 95th percentile peak value during a 1-hour interval.

Enums

AgentStatus

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

Atime

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

AzureAccessTier

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

AzureBlobAuthenticationType

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

AzureBlobType

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

DiscoveryJobStatus

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

DiscoveryResourceFilter

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

DiscoveryResourceType

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

DiscoverySystemType

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

EfsInTransitEncryption

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

EndpointType

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

FilterType

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

Gid

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

HdfsAuthenticationType

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

HdfsDataTransferProtection

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

HdfsRpcProtection

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

LocationFilterName

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

LogLevel

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

ManifestAction

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

ManifestFormat

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

Mtime

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

NfsVersion

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

ObjectStorageServerProtocol

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

ObjectTags

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

ObjectVersionIds

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

Operator

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

OverwriteMode

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

PhaseStatus

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

PosixPermissions

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

PreserveDeletedFiles

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

PreserveDevices

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

RecommendationStatus

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

ReportLevel

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

ReportOutputType

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

S3StorageClass

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

ScheduleDisabledBy

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

ScheduleStatus

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

SmbAuthenticationType

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

SmbSecurityDescriptorCopyFlags

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

SmbVersion

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

StorageSystemConnectivityStatus

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

TaskExecutionStatus

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

TaskFilterName

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

TaskMode

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

TaskQueueing

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

TaskStatus

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

TransferMode

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

Uid

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

VerifyMode

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