#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct AssociateFileSystemAliases {
_private: (),
}
impl AssociateFileSystemAliases {
pub fn builder() -> crate::input::associate_file_system_aliases_input::Builder {
crate::input::associate_file_system_aliases_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for AssociateFileSystemAliases {
type Output = std::result::Result<
crate::output::AssociateFileSystemAliasesOutput,
crate::error::AssociateFileSystemAliasesError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_associate_file_system_aliases_error(response)
} else {
crate::operation_deser::parse_associate_file_system_aliases_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CancelDataRepositoryTask {
_private: (),
}
impl CancelDataRepositoryTask {
pub fn builder() -> crate::input::cancel_data_repository_task_input::Builder {
crate::input::cancel_data_repository_task_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CancelDataRepositoryTask {
type Output = std::result::Result<
crate::output::CancelDataRepositoryTaskOutput,
crate::error::CancelDataRepositoryTaskError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_cancel_data_repository_task_error(response)
} else {
crate::operation_deser::parse_cancel_data_repository_task_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CopyBackup {
_private: (),
}
impl CopyBackup {
pub fn builder() -> crate::input::copy_backup_input::Builder {
crate::input::copy_backup_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CopyBackup {
type Output =
std::result::Result<crate::output::CopyBackupOutput, crate::error::CopyBackupError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_copy_backup_error(response)
} else {
crate::operation_deser::parse_copy_backup_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateBackup {
_private: (),
}
impl CreateBackup {
pub fn builder() -> crate::input::create_backup_input::Builder {
crate::input::create_backup_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateBackup {
type Output =
std::result::Result<crate::output::CreateBackupOutput, crate::error::CreateBackupError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_backup_error(response)
} else {
crate::operation_deser::parse_create_backup_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateDataRepositoryAssociation {
_private: (),
}
impl CreateDataRepositoryAssociation {
pub fn builder() -> crate::input::create_data_repository_association_input::Builder {
crate::input::create_data_repository_association_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDataRepositoryAssociation {
type Output = std::result::Result<
crate::output::CreateDataRepositoryAssociationOutput,
crate::error::CreateDataRepositoryAssociationError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_data_repository_association_error(response)
} else {
crate::operation_deser::parse_create_data_repository_association_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateDataRepositoryTask {
_private: (),
}
impl CreateDataRepositoryTask {
pub fn builder() -> crate::input::create_data_repository_task_input::Builder {
crate::input::create_data_repository_task_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateDataRepositoryTask {
type Output = std::result::Result<
crate::output::CreateDataRepositoryTaskOutput,
crate::error::CreateDataRepositoryTaskError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_data_repository_task_error(response)
} else {
crate::operation_deser::parse_create_data_repository_task_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateFileCache {
_private: (),
}
impl CreateFileCache {
pub fn builder() -> crate::input::create_file_cache_input::Builder {
crate::input::create_file_cache_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateFileCache {
type Output = std::result::Result<
crate::output::CreateFileCacheOutput,
crate::error::CreateFileCacheError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_file_cache_error(response)
} else {
crate::operation_deser::parse_create_file_cache_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateFileSystem {
_private: (),
}
impl CreateFileSystem {
pub fn builder() -> crate::input::create_file_system_input::Builder {
crate::input::create_file_system_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateFileSystem {
type Output = std::result::Result<
crate::output::CreateFileSystemOutput,
crate::error::CreateFileSystemError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_file_system_error(response)
} else {
crate::operation_deser::parse_create_file_system_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateFileSystemFromBackup {
_private: (),
}
impl CreateFileSystemFromBackup {
pub fn builder() -> crate::input::create_file_system_from_backup_input::Builder {
crate::input::create_file_system_from_backup_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateFileSystemFromBackup {
type Output = std::result::Result<
crate::output::CreateFileSystemFromBackupOutput,
crate::error::CreateFileSystemFromBackupError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_file_system_from_backup_error(response)
} else {
crate::operation_deser::parse_create_file_system_from_backup_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateSnapshot {
_private: (),
}
impl CreateSnapshot {
pub fn builder() -> crate::input::create_snapshot_input::Builder {
crate::input::create_snapshot_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateSnapshot {
type Output =
std::result::Result<crate::output::CreateSnapshotOutput, crate::error::CreateSnapshotError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_snapshot_error(response)
} else {
crate::operation_deser::parse_create_snapshot_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateStorageVirtualMachine {
_private: (),
}
impl CreateStorageVirtualMachine {
pub fn builder() -> crate::input::create_storage_virtual_machine_input::Builder {
crate::input::create_storage_virtual_machine_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateStorageVirtualMachine {
type Output = std::result::Result<
crate::output::CreateStorageVirtualMachineOutput,
crate::error::CreateStorageVirtualMachineError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_storage_virtual_machine_error(response)
} else {
crate::operation_deser::parse_create_storage_virtual_machine_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateVolume {
_private: (),
}
impl CreateVolume {
pub fn builder() -> crate::input::create_volume_input::Builder {
crate::input::create_volume_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateVolume {
type Output =
std::result::Result<crate::output::CreateVolumeOutput, crate::error::CreateVolumeError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_volume_error(response)
} else {
crate::operation_deser::parse_create_volume_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct CreateVolumeFromBackup {
_private: (),
}
impl CreateVolumeFromBackup {
pub fn builder() -> crate::input::create_volume_from_backup_input::Builder {
crate::input::create_volume_from_backup_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for CreateVolumeFromBackup {
type Output = std::result::Result<
crate::output::CreateVolumeFromBackupOutput,
crate::error::CreateVolumeFromBackupError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_create_volume_from_backup_error(response)
} else {
crate::operation_deser::parse_create_volume_from_backup_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteBackup {
_private: (),
}
impl DeleteBackup {
pub fn builder() -> crate::input::delete_backup_input::Builder {
crate::input::delete_backup_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteBackup {
type Output =
std::result::Result<crate::output::DeleteBackupOutput, crate::error::DeleteBackupError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_delete_backup_error(response)
} else {
crate::operation_deser::parse_delete_backup_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteDataRepositoryAssociation {
_private: (),
}
impl DeleteDataRepositoryAssociation {
pub fn builder() -> crate::input::delete_data_repository_association_input::Builder {
crate::input::delete_data_repository_association_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteDataRepositoryAssociation {
type Output = std::result::Result<
crate::output::DeleteDataRepositoryAssociationOutput,
crate::error::DeleteDataRepositoryAssociationError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_delete_data_repository_association_error(response)
} else {
crate::operation_deser::parse_delete_data_repository_association_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteFileCache {
_private: (),
}
impl DeleteFileCache {
pub fn builder() -> crate::input::delete_file_cache_input::Builder {
crate::input::delete_file_cache_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteFileCache {
type Output = std::result::Result<
crate::output::DeleteFileCacheOutput,
crate::error::DeleteFileCacheError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_delete_file_cache_error(response)
} else {
crate::operation_deser::parse_delete_file_cache_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteFileSystem {
_private: (),
}
impl DeleteFileSystem {
pub fn builder() -> crate::input::delete_file_system_input::Builder {
crate::input::delete_file_system_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteFileSystem {
type Output = std::result::Result<
crate::output::DeleteFileSystemOutput,
crate::error::DeleteFileSystemError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_delete_file_system_error(response)
} else {
crate::operation_deser::parse_delete_file_system_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteSnapshot {
_private: (),
}
impl DeleteSnapshot {
pub fn builder() -> crate::input::delete_snapshot_input::Builder {
crate::input::delete_snapshot_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteSnapshot {
type Output =
std::result::Result<crate::output::DeleteSnapshotOutput, crate::error::DeleteSnapshotError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_delete_snapshot_error(response)
} else {
crate::operation_deser::parse_delete_snapshot_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteStorageVirtualMachine {
_private: (),
}
impl DeleteStorageVirtualMachine {
pub fn builder() -> crate::input::delete_storage_virtual_machine_input::Builder {
crate::input::delete_storage_virtual_machine_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteStorageVirtualMachine {
type Output = std::result::Result<
crate::output::DeleteStorageVirtualMachineOutput,
crate::error::DeleteStorageVirtualMachineError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_delete_storage_virtual_machine_error(response)
} else {
crate::operation_deser::parse_delete_storage_virtual_machine_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DeleteVolume {
_private: (),
}
impl DeleteVolume {
pub fn builder() -> crate::input::delete_volume_input::Builder {
crate::input::delete_volume_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DeleteVolume {
type Output =
std::result::Result<crate::output::DeleteVolumeOutput, crate::error::DeleteVolumeError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_delete_volume_error(response)
} else {
crate::operation_deser::parse_delete_volume_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeBackups {
_private: (),
}
impl DescribeBackups {
pub fn builder() -> crate::input::describe_backups_input::Builder {
crate::input::describe_backups_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeBackups {
type Output = std::result::Result<
crate::output::DescribeBackupsOutput,
crate::error::DescribeBackupsError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_backups_error(response)
} else {
crate::operation_deser::parse_describe_backups_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeDataRepositoryAssociations {
_private: (),
}
impl DescribeDataRepositoryAssociations {
pub fn builder() -> crate::input::describe_data_repository_associations_input::Builder {
crate::input::describe_data_repository_associations_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeDataRepositoryAssociations {
type Output = std::result::Result<
crate::output::DescribeDataRepositoryAssociationsOutput,
crate::error::DescribeDataRepositoryAssociationsError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_data_repository_associations_error(response)
} else {
crate::operation_deser::parse_describe_data_repository_associations_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeDataRepositoryTasks {
_private: (),
}
impl DescribeDataRepositoryTasks {
pub fn builder() -> crate::input::describe_data_repository_tasks_input::Builder {
crate::input::describe_data_repository_tasks_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeDataRepositoryTasks {
type Output = std::result::Result<
crate::output::DescribeDataRepositoryTasksOutput,
crate::error::DescribeDataRepositoryTasksError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_data_repository_tasks_error(response)
} else {
crate::operation_deser::parse_describe_data_repository_tasks_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeFileCaches {
_private: (),
}
impl DescribeFileCaches {
pub fn builder() -> crate::input::describe_file_caches_input::Builder {
crate::input::describe_file_caches_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeFileCaches {
type Output = std::result::Result<
crate::output::DescribeFileCachesOutput,
crate::error::DescribeFileCachesError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_file_caches_error(response)
} else {
crate::operation_deser::parse_describe_file_caches_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeFileSystemAliases {
_private: (),
}
impl DescribeFileSystemAliases {
pub fn builder() -> crate::input::describe_file_system_aliases_input::Builder {
crate::input::describe_file_system_aliases_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeFileSystemAliases {
type Output = std::result::Result<
crate::output::DescribeFileSystemAliasesOutput,
crate::error::DescribeFileSystemAliasesError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_file_system_aliases_error(response)
} else {
crate::operation_deser::parse_describe_file_system_aliases_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeFileSystems {
_private: (),
}
impl DescribeFileSystems {
pub fn builder() -> crate::input::describe_file_systems_input::Builder {
crate::input::describe_file_systems_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeFileSystems {
type Output = std::result::Result<
crate::output::DescribeFileSystemsOutput,
crate::error::DescribeFileSystemsError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_file_systems_error(response)
} else {
crate::operation_deser::parse_describe_file_systems_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeSnapshots {
_private: (),
}
impl DescribeSnapshots {
pub fn builder() -> crate::input::describe_snapshots_input::Builder {
crate::input::describe_snapshots_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeSnapshots {
type Output = std::result::Result<
crate::output::DescribeSnapshotsOutput,
crate::error::DescribeSnapshotsError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_snapshots_error(response)
} else {
crate::operation_deser::parse_describe_snapshots_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeStorageVirtualMachines {
_private: (),
}
impl DescribeStorageVirtualMachines {
pub fn builder() -> crate::input::describe_storage_virtual_machines_input::Builder {
crate::input::describe_storage_virtual_machines_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeStorageVirtualMachines {
type Output = std::result::Result<
crate::output::DescribeStorageVirtualMachinesOutput,
crate::error::DescribeStorageVirtualMachinesError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_storage_virtual_machines_error(response)
} else {
crate::operation_deser::parse_describe_storage_virtual_machines_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DescribeVolumes {
_private: (),
}
impl DescribeVolumes {
pub fn builder() -> crate::input::describe_volumes_input::Builder {
crate::input::describe_volumes_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DescribeVolumes {
type Output = std::result::Result<
crate::output::DescribeVolumesOutput,
crate::error::DescribeVolumesError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_describe_volumes_error(response)
} else {
crate::operation_deser::parse_describe_volumes_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct DisassociateFileSystemAliases {
_private: (),
}
impl DisassociateFileSystemAliases {
pub fn builder() -> crate::input::disassociate_file_system_aliases_input::Builder {
crate::input::disassociate_file_system_aliases_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for DisassociateFileSystemAliases {
type Output = std::result::Result<
crate::output::DisassociateFileSystemAliasesOutput,
crate::error::DisassociateFileSystemAliasesError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_disassociate_file_system_aliases_error(response)
} else {
crate::operation_deser::parse_disassociate_file_system_aliases_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ListTagsForResource {
_private: (),
}
impl ListTagsForResource {
pub fn builder() -> crate::input::list_tags_for_resource_input::Builder {
crate::input::list_tags_for_resource_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for ListTagsForResource {
type Output = std::result::Result<
crate::output::ListTagsForResourceOutput,
crate::error::ListTagsForResourceError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_list_tags_for_resource_error(response)
} else {
crate::operation_deser::parse_list_tags_for_resource_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct ReleaseFileSystemNfsV3Locks {
_private: (),
}
impl ReleaseFileSystemNfsV3Locks {
pub fn builder() -> crate::input::release_file_system_nfs_v3_locks_input::Builder {
crate::input::release_file_system_nfs_v3_locks_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for ReleaseFileSystemNfsV3Locks {
type Output = std::result::Result<
crate::output::ReleaseFileSystemNfsV3LocksOutput,
crate::error::ReleaseFileSystemNfsV3LocksError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_release_file_system_nfs_v3_locks_error(response)
} else {
crate::operation_deser::parse_release_file_system_nfs_v3_locks_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct RestoreVolumeFromSnapshot {
_private: (),
}
impl RestoreVolumeFromSnapshot {
pub fn builder() -> crate::input::restore_volume_from_snapshot_input::Builder {
crate::input::restore_volume_from_snapshot_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for RestoreVolumeFromSnapshot {
type Output = std::result::Result<
crate::output::RestoreVolumeFromSnapshotOutput,
crate::error::RestoreVolumeFromSnapshotError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_restore_volume_from_snapshot_error(response)
} else {
crate::operation_deser::parse_restore_volume_from_snapshot_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct TagResource {
_private: (),
}
impl TagResource {
pub fn builder() -> crate::input::tag_resource_input::Builder {
crate::input::tag_resource_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for TagResource {
type Output =
std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_tag_resource_error(response)
} else {
crate::operation_deser::parse_tag_resource_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UntagResource {
_private: (),
}
impl UntagResource {
pub fn builder() -> crate::input::untag_resource_input::Builder {
crate::input::untag_resource_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for UntagResource {
type Output =
std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_untag_resource_error(response)
} else {
crate::operation_deser::parse_untag_resource_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateDataRepositoryAssociation {
_private: (),
}
impl UpdateDataRepositoryAssociation {
pub fn builder() -> crate::input::update_data_repository_association_input::Builder {
crate::input::update_data_repository_association_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateDataRepositoryAssociation {
type Output = std::result::Result<
crate::output::UpdateDataRepositoryAssociationOutput,
crate::error::UpdateDataRepositoryAssociationError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_update_data_repository_association_error(response)
} else {
crate::operation_deser::parse_update_data_repository_association_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateFileCache {
_private: (),
}
impl UpdateFileCache {
pub fn builder() -> crate::input::update_file_cache_input::Builder {
crate::input::update_file_cache_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateFileCache {
type Output = std::result::Result<
crate::output::UpdateFileCacheOutput,
crate::error::UpdateFileCacheError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_update_file_cache_error(response)
} else {
crate::operation_deser::parse_update_file_cache_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateFileSystem {
_private: (),
}
impl UpdateFileSystem {
pub fn builder() -> crate::input::update_file_system_input::Builder {
crate::input::update_file_system_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateFileSystem {
type Output = std::result::Result<
crate::output::UpdateFileSystemOutput,
crate::error::UpdateFileSystemError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_update_file_system_error(response)
} else {
crate::operation_deser::parse_update_file_system_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateSnapshot {
_private: (),
}
impl UpdateSnapshot {
pub fn builder() -> crate::input::update_snapshot_input::Builder {
crate::input::update_snapshot_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateSnapshot {
type Output =
std::result::Result<crate::output::UpdateSnapshotOutput, crate::error::UpdateSnapshotError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_update_snapshot_error(response)
} else {
crate::operation_deser::parse_update_snapshot_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateStorageVirtualMachine {
_private: (),
}
impl UpdateStorageVirtualMachine {
pub fn builder() -> crate::input::update_storage_virtual_machine_input::Builder {
crate::input::update_storage_virtual_machine_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateStorageVirtualMachine {
type Output = std::result::Result<
crate::output::UpdateStorageVirtualMachineOutput,
crate::error::UpdateStorageVirtualMachineError,
>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_update_storage_virtual_machine_error(response)
} else {
crate::operation_deser::parse_update_storage_virtual_machine_response(response)
}
}
}
#[derive(std::clone::Clone, std::default::Default, std::fmt::Debug)]
pub struct UpdateVolume {
_private: (),
}
impl UpdateVolume {
pub fn builder() -> crate::input::update_volume_input::Builder {
crate::input::update_volume_input::Builder::default()
}
pub fn new() -> Self {
Self { _private: () }
}
}
impl aws_smithy_http::response::ParseStrictResponse for UpdateVolume {
type Output =
std::result::Result<crate::output::UpdateVolumeOutput, crate::error::UpdateVolumeError>;
fn parse(&self, response: &http::Response<bytes::Bytes>) -> Self::Output {
if !response.status().is_success() && response.status().as_u16() != 200 {
crate::operation_deser::parse_update_volume_error(response)
} else {
crate::operation_deser::parse_update_volume_response(response)
}
}
}
pub mod customize;