use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ActivateGatewayInput {
#[serde(rename = "ActivationKey")]
pub activation_key: String,
#[serde(rename = "GatewayName")]
pub gateway_name: String,
#[serde(rename = "GatewayRegion")]
pub gateway_region: String,
#[serde(rename = "GatewayTimezone")]
pub gateway_timezone: String,
#[serde(rename = "GatewayType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_type: Option<String>,
#[serde(rename = "MediumChangerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub medium_changer_type: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TapeDriveType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_drive_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ActivateGatewayOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddCacheInput {
#[serde(rename = "DiskIds")]
pub disk_ids: Vec<String>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddCacheOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddTagsToResourceInput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddTagsToResourceOutput {
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddUploadBufferInput {
#[serde(rename = "DiskIds")]
pub disk_ids: Vec<String>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddUploadBufferOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddWorkingStorageInput {
#[serde(rename = "DiskIds")]
pub disk_ids: Vec<String>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddWorkingStorageOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssignTapePoolInput {
#[serde(rename = "PoolId")]
pub pool_id: String,
#[serde(rename = "TapeARN")]
pub tape_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssignTapePoolOutput {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachVolumeInput {
#[serde(rename = "DiskId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_id: Option<String>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "NetworkInterfaceId")]
pub network_interface_id: String,
#[serde(rename = "TargetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_name: Option<String>,
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachVolumeOutput {
#[serde(rename = "TargetARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutomaticTapeCreationPolicyInfo {
#[serde(rename = "AutomaticTapeCreationRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic_tape_creation_rules: Option<Vec<AutomaticTapeCreationRule>>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct AutomaticTapeCreationRule {
#[serde(rename = "MinimumNumTapes")]
pub minimum_num_tapes: i64,
#[serde(rename = "PoolId")]
pub pool_id: String,
#[serde(rename = "TapeBarcodePrefix")]
pub tape_barcode_prefix: String,
#[serde(rename = "TapeSizeInBytes")]
pub tape_size_in_bytes: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CachediSCSIVolume {
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "SourceSnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_snapshot_id: Option<String>,
#[serde(rename = "TargetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_name: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
#[serde(rename = "VolumeAttachmentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_attachment_status: Option<String>,
#[serde(rename = "VolumeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_id: Option<String>,
#[serde(rename = "VolumeProgress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_progress: Option<f64>,
#[serde(rename = "VolumeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_size_in_bytes: Option<i64>,
#[serde(rename = "VolumeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_status: Option<String>,
#[serde(rename = "VolumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
#[serde(rename = "VolumeUsedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_used_in_bytes: Option<i64>,
#[serde(rename = "VolumeiSCSIAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volumei_scsi_attributes: Option<VolumeiSCSIAttributes>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelArchivalInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "TapeARN")]
pub tape_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelArchivalOutput {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CancelRetrievalInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "TapeARN")]
pub tape_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CancelRetrievalOutput {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ChapInfo {
#[serde(rename = "InitiatorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initiator_name: Option<String>,
#[serde(rename = "SecretToAuthenticateInitiator")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_to_authenticate_initiator: Option<String>,
#[serde(rename = "SecretToAuthenticateTarget")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_to_authenticate_target: Option<String>,
#[serde(rename = "TargetARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCachediSCSIVolumeInput {
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "NetworkInterfaceId")]
pub network_interface_id: String,
#[serde(rename = "SnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
#[serde(rename = "SourceVolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_volume_arn: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TargetName")]
pub target_name: String,
#[serde(rename = "VolumeSizeInBytes")]
pub volume_size_in_bytes: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCachediSCSIVolumeOutput {
#[serde(rename = "TargetARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateNFSFileShareInput {
#[serde(rename = "ClientList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_list: Option<Vec<String>>,
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "DefaultStorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_storage_class: Option<String>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "GuessMIMETypeEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guess_mime_type_enabled: Option<bool>,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LocationARN")]
pub location_arn: String,
#[serde(rename = "NFSFileShareDefaults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nfs_file_share_defaults: Option<NFSFileShareDefaults>,
#[serde(rename = "ObjectACL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_acl: Option<String>,
#[serde(rename = "ReadOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_only: Option<bool>,
#[serde(rename = "RequesterPays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_pays: Option<bool>,
#[serde(rename = "Role")]
pub role: String,
#[serde(rename = "Squash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub squash: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateNFSFileShareOutput {
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSMBFileShareInput {
#[serde(rename = "AdminUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_user_list: Option<Vec<String>>,
#[serde(rename = "AuditDestinationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audit_destination_arn: Option<String>,
#[serde(rename = "Authentication")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication: Option<String>,
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "DefaultStorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_storage_class: Option<String>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "GuessMIMETypeEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guess_mime_type_enabled: Option<bool>,
#[serde(rename = "InvalidUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invalid_user_list: Option<Vec<String>>,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LocationARN")]
pub location_arn: String,
#[serde(rename = "ObjectACL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_acl: Option<String>,
#[serde(rename = "ReadOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_only: Option<bool>,
#[serde(rename = "RequesterPays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_pays: Option<bool>,
#[serde(rename = "Role")]
pub role: String,
#[serde(rename = "SMBACLEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smbacl_enabled: Option<bool>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "ValidUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub valid_user_list: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSMBFileShareOutput {
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSnapshotFromVolumeRecoveryPointInput {
#[serde(rename = "SnapshotDescription")]
pub snapshot_description: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSnapshotFromVolumeRecoveryPointOutput {
#[serde(rename = "SnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
#[serde(rename = "VolumeRecoveryPointTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_recovery_point_time: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSnapshotInput {
#[serde(rename = "SnapshotDescription")]
pub snapshot_description: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSnapshotOutput {
#[serde(rename = "SnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateStorediSCSIVolumeInput {
#[serde(rename = "DiskId")]
pub disk_id: String,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "NetworkInterfaceId")]
pub network_interface_id: String,
#[serde(rename = "PreserveExistingData")]
pub preserve_existing_data: bool,
#[serde(rename = "SnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub snapshot_id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TargetName")]
pub target_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateStorediSCSIVolumeOutput {
#[serde(rename = "TargetARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
#[serde(rename = "VolumeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_size_in_bytes: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTapeWithBarcodeInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "PoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pool_id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TapeBarcode")]
pub tape_barcode: String,
#[serde(rename = "TapeSizeInBytes")]
pub tape_size_in_bytes: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTapeWithBarcodeOutput {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTapesInput {
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "NumTapesToCreate")]
pub num_tapes_to_create: i64,
#[serde(rename = "PoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pool_id: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "TapeBarcodePrefix")]
pub tape_barcode_prefix: String,
#[serde(rename = "TapeSizeInBytes")]
pub tape_size_in_bytes: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTapesOutput {
#[serde(rename = "TapeARNs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_ar_ns: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAutomaticTapeCreationPolicyInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAutomaticTapeCreationPolicyOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBandwidthRateLimitInput {
#[serde(rename = "BandwidthType")]
pub bandwidth_type: String,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteBandwidthRateLimitOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteChapCredentialsInput {
#[serde(rename = "InitiatorName")]
pub initiator_name: String,
#[serde(rename = "TargetARN")]
pub target_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteChapCredentialsOutput {
#[serde(rename = "InitiatorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initiator_name: Option<String>,
#[serde(rename = "TargetARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFileShareInput {
#[serde(rename = "FileShareARN")]
pub file_share_arn: String,
#[serde(rename = "ForceDelete")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_delete: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFileShareOutput {
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteGatewayInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteGatewayOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSnapshotScheduleInput {
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteSnapshotScheduleOutput {
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTapeArchiveInput {
#[serde(rename = "TapeARN")]
pub tape_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTapeArchiveOutput {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTapeInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "TapeARN")]
pub tape_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTapeOutput {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteVolumeInput {
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteVolumeOutput {
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeAvailabilityMonitorTestInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeAvailabilityMonitorTestOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "StartTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeBandwidthRateLimitInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeBandwidthRateLimitOutput {
#[serde(rename = "AverageDownloadRateLimitInBitsPerSec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub average_download_rate_limit_in_bits_per_sec: Option<i64>,
#[serde(rename = "AverageUploadRateLimitInBitsPerSec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub average_upload_rate_limit_in_bits_per_sec: Option<i64>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCacheInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCacheOutput {
#[serde(rename = "CacheAllocatedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_allocated_in_bytes: Option<i64>,
#[serde(rename = "CacheDirtyPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_dirty_percentage: Option<f64>,
#[serde(rename = "CacheHitPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_hit_percentage: Option<f64>,
#[serde(rename = "CacheMissPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_miss_percentage: Option<f64>,
#[serde(rename = "CacheUsedPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cache_used_percentage: Option<f64>,
#[serde(rename = "DiskIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_ids: Option<Vec<String>>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCachediSCSIVolumesInput {
#[serde(rename = "VolumeARNs")]
pub volume_ar_ns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCachediSCSIVolumesOutput {
#[serde(rename = "CachediSCSIVolumes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cachedi_scsi_volumes: Option<Vec<CachediSCSIVolume>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeChapCredentialsInput {
#[serde(rename = "TargetARN")]
pub target_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeChapCredentialsOutput {
#[serde(rename = "ChapCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chap_credentials: Option<Vec<ChapInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeGatewayInformationInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeGatewayInformationOutput {
#[serde(rename = "CloudWatchLogGroupARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_log_group_arn: Option<String>,
#[serde(rename = "Ec2InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_instance_id: Option<String>,
#[serde(rename = "Ec2InstanceRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_instance_region: Option<String>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "GatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_id: Option<String>,
#[serde(rename = "GatewayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_name: Option<String>,
#[serde(rename = "GatewayNetworkInterfaces")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_network_interfaces: Option<Vec<NetworkInterface>>,
#[serde(rename = "GatewayState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_state: Option<String>,
#[serde(rename = "GatewayTimezone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_timezone: Option<String>,
#[serde(rename = "GatewayType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_type: Option<String>,
#[serde(rename = "HostEnvironment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub host_environment: Option<String>,
#[serde(rename = "LastSoftwareUpdate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_software_update: Option<String>,
#[serde(rename = "NextUpdateAvailabilityDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_update_availability_date: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "VPCEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_endpoint: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeMaintenanceStartTimeInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeMaintenanceStartTimeOutput {
#[serde(rename = "DayOfMonth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub day_of_month: Option<i64>,
#[serde(rename = "DayOfWeek")]
#[serde(skip_serializing_if = "Option::is_none")]
pub day_of_week: Option<i64>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "HourOfDay")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hour_of_day: Option<i64>,
#[serde(rename = "MinuteOfHour")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minute_of_hour: Option<i64>,
#[serde(rename = "Timezone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timezone: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeNFSFileSharesInput {
#[serde(rename = "FileShareARNList")]
pub file_share_arn_list: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeNFSFileSharesOutput {
#[serde(rename = "NFSFileShareInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nfs_file_share_info_list: Option<Vec<NFSFileShareInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSMBFileSharesInput {
#[serde(rename = "FileShareARNList")]
pub file_share_arn_list: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSMBFileSharesOutput {
#[serde(rename = "SMBFileShareInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smb_file_share_info_list: Option<Vec<SMBFileShareInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSMBSettingsInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSMBSettingsOutput {
#[serde(rename = "ActiveDirectoryStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active_directory_status: Option<String>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "SMBGuestPasswordSet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smb_guest_password_set: Option<bool>,
#[serde(rename = "SMBSecurityStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smb_security_strategy: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeSnapshotScheduleInput {
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeSnapshotScheduleOutput {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "RecurrenceInHours")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recurrence_in_hours: Option<i64>,
#[serde(rename = "StartAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_at: Option<i64>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "Timezone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timezone: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeStorediSCSIVolumesInput {
#[serde(rename = "VolumeARNs")]
pub volume_ar_ns: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeStorediSCSIVolumesOutput {
#[serde(rename = "StorediSCSIVolumes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storedi_scsi_volumes: Option<Vec<StorediSCSIVolume>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTapeArchivesInput {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "TapeARNs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_ar_ns: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTapeArchivesOutput {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "TapeArchives")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_archives: Option<Vec<TapeArchive>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTapeRecoveryPointsInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTapeRecoveryPointsOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "TapeRecoveryPointInfos")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_recovery_point_infos: Option<Vec<TapeRecoveryPointInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTapesInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "TapeARNs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_ar_ns: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTapesOutput {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "Tapes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tapes: Option<Vec<Tape>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeUploadBufferInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeUploadBufferOutput {
#[serde(rename = "DiskIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_ids: Option<Vec<String>>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "UploadBufferAllocatedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upload_buffer_allocated_in_bytes: Option<i64>,
#[serde(rename = "UploadBufferUsedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upload_buffer_used_in_bytes: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeVTLDevicesInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "VTLDeviceARNs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vtl_device_ar_ns: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeVTLDevicesOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "VTLDevices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vtl_devices: Option<Vec<VTLDevice>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeWorkingStorageInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeWorkingStorageOutput {
#[serde(rename = "DiskIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_ids: Option<Vec<String>>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "WorkingStorageAllocatedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub working_storage_allocated_in_bytes: Option<i64>,
#[serde(rename = "WorkingStorageUsedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub working_storage_used_in_bytes: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachVolumeInput {
#[serde(rename = "ForceDetach")]
#[serde(skip_serializing_if = "Option::is_none")]
pub force_detach: Option<bool>,
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetachVolumeOutput {
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeviceiSCSIAttributes {
#[serde(rename = "ChapEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chap_enabled: Option<bool>,
#[serde(rename = "NetworkInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface_id: Option<String>,
#[serde(rename = "NetworkInterfacePort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface_port: Option<i64>,
#[serde(rename = "TargetARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableGatewayInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableGatewayOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Disk {
#[serde(rename = "DiskAllocationResource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_allocation_resource: Option<String>,
#[serde(rename = "DiskAllocationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_allocation_type: Option<String>,
#[serde(rename = "DiskAttributeList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_attribute_list: Option<Vec<String>>,
#[serde(rename = "DiskId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_id: Option<String>,
#[serde(rename = "DiskNode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_node: Option<String>,
#[serde(rename = "DiskPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_path: Option<String>,
#[serde(rename = "DiskSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_size_in_bytes: Option<i64>,
#[serde(rename = "DiskStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disk_status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FileShareInfo {
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
#[serde(rename = "FileShareId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_id: Option<String>,
#[serde(rename = "FileShareStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_status: Option<String>,
#[serde(rename = "FileShareType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_type: Option<String>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GatewayInfo {
#[serde(rename = "Ec2InstanceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_instance_id: Option<String>,
#[serde(rename = "Ec2InstanceRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ec_2_instance_region: Option<String>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "GatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_id: Option<String>,
#[serde(rename = "GatewayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_name: Option<String>,
#[serde(rename = "GatewayOperationalState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_operational_state: Option<String>,
#[serde(rename = "GatewayType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct JoinDomainInput {
#[serde(rename = "DomainControllers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_controllers: Option<Vec<String>>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "OrganizationalUnit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organizational_unit: Option<String>,
#[serde(rename = "Password")]
pub password: String,
#[serde(rename = "TimeoutInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_in_seconds: Option<i64>,
#[serde(rename = "UserName")]
pub user_name: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct JoinDomainOutput {
#[serde(rename = "ActiveDirectoryStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active_directory_status: Option<String>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAutomaticTapeCreationPoliciesInput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAutomaticTapeCreationPoliciesOutput {
#[serde(rename = "AutomaticTapeCreationPolicyInfos")]
#[serde(skip_serializing_if = "Option::is_none")]
pub automatic_tape_creation_policy_infos: Option<Vec<AutomaticTapeCreationPolicyInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFileSharesInput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFileSharesOutput {
#[serde(rename = "FileShareInfoList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_info_list: Option<Vec<FileShareInfo>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListGatewaysInput {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListGatewaysOutput {
#[serde(rename = "Gateways")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateways: Option<Vec<GatewayInfo>>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLocalDisksInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLocalDisksOutput {
#[serde(rename = "Disks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disks: Option<Vec<Disk>>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceInput {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceOutput {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTapesInput {
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "TapeARNs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_ar_ns: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTapesOutput {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "TapeInfos")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_infos: Option<Vec<TapeInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListVolumeInitiatorsInput {
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListVolumeInitiatorsOutput {
#[serde(rename = "Initiators")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initiators: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListVolumeRecoveryPointsInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListVolumeRecoveryPointsOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "VolumeRecoveryPointInfos")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_recovery_point_infos: Option<Vec<VolumeRecoveryPointInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListVolumesInput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "Limit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListVolumesOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "VolumeInfos")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_infos: Option<Vec<VolumeInfo>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct NFSFileShareDefaults {
#[serde(rename = "DirectoryMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_mode: Option<String>,
#[serde(rename = "FileMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_mode: Option<String>,
#[serde(rename = "GroupId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub group_id: Option<i64>,
#[serde(rename = "OwnerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_id: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NFSFileShareInfo {
#[serde(rename = "ClientList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_list: Option<Vec<String>>,
#[serde(rename = "DefaultStorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_storage_class: Option<String>,
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
#[serde(rename = "FileShareId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_id: Option<String>,
#[serde(rename = "FileShareStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_status: Option<String>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "GuessMIMETypeEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guess_mime_type_enabled: Option<bool>,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LocationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
#[serde(rename = "NFSFileShareDefaults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nfs_file_share_defaults: Option<NFSFileShareDefaults>,
#[serde(rename = "ObjectACL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_acl: Option<String>,
#[serde(rename = "Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
#[serde(rename = "ReadOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_only: Option<bool>,
#[serde(rename = "RequesterPays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_pays: Option<bool>,
#[serde(rename = "Role")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(rename = "Squash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub squash: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NetworkInterface {
#[serde(rename = "Ipv4Address")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ipv_4_address: Option<String>,
#[serde(rename = "Ipv6Address")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ipv_6_address: Option<String>,
#[serde(rename = "MacAddress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mac_address: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct NotifyWhenUploadedInput {
#[serde(rename = "FileShareARN")]
pub file_share_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct NotifyWhenUploadedOutput {
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
#[serde(rename = "NotificationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RefreshCacheInput {
#[serde(rename = "FileShareARN")]
pub file_share_arn: String,
#[serde(rename = "FolderList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub folder_list: Option<Vec<String>>,
#[serde(rename = "Recursive")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recursive: Option<bool>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RefreshCacheOutput {
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
#[serde(rename = "NotificationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_id: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveTagsFromResourceInput {
#[serde(rename = "ResourceARN")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoveTagsFromResourceOutput {
#[serde(rename = "ResourceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ResetCacheInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResetCacheOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RetrieveTapeArchiveInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "TapeARN")]
pub tape_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RetrieveTapeArchiveOutput {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RetrieveTapeRecoveryPointInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "TapeARN")]
pub tape_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RetrieveTapeRecoveryPointOutput {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SMBFileShareInfo {
#[serde(rename = "AdminUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_user_list: Option<Vec<String>>,
#[serde(rename = "AuditDestinationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audit_destination_arn: Option<String>,
#[serde(rename = "Authentication")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication: Option<String>,
#[serde(rename = "DefaultStorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_storage_class: Option<String>,
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
#[serde(rename = "FileShareId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_id: Option<String>,
#[serde(rename = "FileShareStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_status: Option<String>,
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "GuessMIMETypeEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guess_mime_type_enabled: Option<bool>,
#[serde(rename = "InvalidUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invalid_user_list: Option<Vec<String>>,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "LocationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location_arn: Option<String>,
#[serde(rename = "ObjectACL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_acl: Option<String>,
#[serde(rename = "Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
#[serde(rename = "ReadOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_only: Option<bool>,
#[serde(rename = "RequesterPays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_pays: Option<bool>,
#[serde(rename = "Role")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(rename = "SMBACLEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smbacl_enabled: Option<bool>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "ValidUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub valid_user_list: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetLocalConsolePasswordInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "LocalConsolePassword")]
pub local_console_password: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SetLocalConsolePasswordOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetSMBGuestPasswordInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "Password")]
pub password: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SetSMBGuestPasswordOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ShutdownGatewayInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ShutdownGatewayOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartAvailabilityMonitorTestInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartAvailabilityMonitorTestOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartGatewayInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartGatewayOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq)]
pub struct StorageGatewayError {
pub error_code: Option<String>,
pub error_details: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StorediSCSIVolume {
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "PreservedExistingData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub preserved_existing_data: Option<bool>,
#[serde(rename = "SourceSnapshotId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_snapshot_id: Option<String>,
#[serde(rename = "TargetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_name: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
#[serde(rename = "VolumeAttachmentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_attachment_status: Option<String>,
#[serde(rename = "VolumeDiskId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_disk_id: Option<String>,
#[serde(rename = "VolumeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_id: Option<String>,
#[serde(rename = "VolumeProgress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_progress: Option<f64>,
#[serde(rename = "VolumeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_size_in_bytes: Option<i64>,
#[serde(rename = "VolumeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_status: Option<String>,
#[serde(rename = "VolumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
#[serde(rename = "VolumeUsedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_used_in_bytes: Option<i64>,
#[serde(rename = "VolumeiSCSIAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volumei_scsi_attributes: Option<VolumeiSCSIAttributes>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Tape {
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "PoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pool_id: Option<String>,
#[serde(rename = "Progress")]
#[serde(skip_serializing_if = "Option::is_none")]
pub progress: Option<f64>,
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
#[serde(rename = "TapeBarcode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_barcode: Option<String>,
#[serde(rename = "TapeCreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_created_date: Option<f64>,
#[serde(rename = "TapeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_size_in_bytes: Option<i64>,
#[serde(rename = "TapeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_status: Option<String>,
#[serde(rename = "TapeUsedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_used_in_bytes: Option<i64>,
#[serde(rename = "VTLDevice")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vtl_device: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TapeArchive {
#[serde(rename = "CompletionTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_time: Option<f64>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "PoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pool_id: Option<String>,
#[serde(rename = "RetrievedTo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub retrieved_to: Option<String>,
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
#[serde(rename = "TapeBarcode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_barcode: Option<String>,
#[serde(rename = "TapeCreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_created_date: Option<f64>,
#[serde(rename = "TapeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_size_in_bytes: Option<i64>,
#[serde(rename = "TapeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_status: Option<String>,
#[serde(rename = "TapeUsedInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_used_in_bytes: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TapeInfo {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "PoolId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pool_id: Option<String>,
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
#[serde(rename = "TapeBarcode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_barcode: Option<String>,
#[serde(rename = "TapeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_size_in_bytes: Option<i64>,
#[serde(rename = "TapeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TapeRecoveryPointInfo {
#[serde(rename = "TapeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_arn: Option<String>,
#[serde(rename = "TapeRecoveryPointTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_recovery_point_time: Option<f64>,
#[serde(rename = "TapeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_size_in_bytes: Option<i64>,
#[serde(rename = "TapeStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tape_status: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAutomaticTapeCreationPolicyInput {
#[serde(rename = "AutomaticTapeCreationRules")]
pub automatic_tape_creation_rules: Vec<AutomaticTapeCreationRule>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateAutomaticTapeCreationPolicyOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateBandwidthRateLimitInput {
#[serde(rename = "AverageDownloadRateLimitInBitsPerSec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub average_download_rate_limit_in_bits_per_sec: Option<i64>,
#[serde(rename = "AverageUploadRateLimitInBitsPerSec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub average_upload_rate_limit_in_bits_per_sec: Option<i64>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateBandwidthRateLimitOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateChapCredentialsInput {
#[serde(rename = "InitiatorName")]
pub initiator_name: String,
#[serde(rename = "SecretToAuthenticateInitiator")]
pub secret_to_authenticate_initiator: String,
#[serde(rename = "SecretToAuthenticateTarget")]
#[serde(skip_serializing_if = "Option::is_none")]
pub secret_to_authenticate_target: Option<String>,
#[serde(rename = "TargetARN")]
pub target_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateChapCredentialsOutput {
#[serde(rename = "InitiatorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub initiator_name: Option<String>,
#[serde(rename = "TargetARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateGatewayInformationInput {
#[serde(rename = "CloudWatchLogGroupARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_log_group_arn: Option<String>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "GatewayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_name: Option<String>,
#[serde(rename = "GatewayTimezone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_timezone: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateGatewayInformationOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "GatewayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_name: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateGatewaySoftwareNowInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateGatewaySoftwareNowOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateMaintenanceStartTimeInput {
#[serde(rename = "DayOfMonth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub day_of_month: Option<i64>,
#[serde(rename = "DayOfWeek")]
#[serde(skip_serializing_if = "Option::is_none")]
pub day_of_week: Option<i64>,
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "HourOfDay")]
pub hour_of_day: i64,
#[serde(rename = "MinuteOfHour")]
pub minute_of_hour: i64,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateMaintenanceStartTimeOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateNFSFileShareInput {
#[serde(rename = "ClientList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_list: Option<Vec<String>>,
#[serde(rename = "DefaultStorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_storage_class: Option<String>,
#[serde(rename = "FileShareARN")]
pub file_share_arn: String,
#[serde(rename = "GuessMIMETypeEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guess_mime_type_enabled: Option<bool>,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "NFSFileShareDefaults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub nfs_file_share_defaults: Option<NFSFileShareDefaults>,
#[serde(rename = "ObjectACL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_acl: Option<String>,
#[serde(rename = "ReadOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_only: Option<bool>,
#[serde(rename = "RequesterPays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_pays: Option<bool>,
#[serde(rename = "Squash")]
#[serde(skip_serializing_if = "Option::is_none")]
pub squash: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateNFSFileShareOutput {
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateSMBFileShareInput {
#[serde(rename = "AdminUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub admin_user_list: Option<Vec<String>>,
#[serde(rename = "AuditDestinationARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audit_destination_arn: Option<String>,
#[serde(rename = "DefaultStorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_storage_class: Option<String>,
#[serde(rename = "FileShareARN")]
pub file_share_arn: String,
#[serde(rename = "GuessMIMETypeEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guess_mime_type_enabled: Option<bool>,
#[serde(rename = "InvalidUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invalid_user_list: Option<Vec<String>>,
#[serde(rename = "KMSEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_encrypted: Option<bool>,
#[serde(rename = "KMSKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key: Option<String>,
#[serde(rename = "ObjectACL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_acl: Option<String>,
#[serde(rename = "ReadOnly")]
#[serde(skip_serializing_if = "Option::is_none")]
pub read_only: Option<bool>,
#[serde(rename = "RequesterPays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requester_pays: Option<bool>,
#[serde(rename = "SMBACLEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub smbacl_enabled: Option<bool>,
#[serde(rename = "ValidUserList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub valid_user_list: Option<Vec<String>>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateSMBFileShareOutput {
#[serde(rename = "FileShareARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_share_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateSMBSecurityStrategyInput {
#[serde(rename = "GatewayARN")]
pub gateway_arn: String,
#[serde(rename = "SMBSecurityStrategy")]
pub smb_security_strategy: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateSMBSecurityStrategyOutput {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateSnapshotScheduleInput {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "RecurrenceInHours")]
pub recurrence_in_hours: i64,
#[serde(rename = "StartAt")]
pub start_at: i64,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "VolumeARN")]
pub volume_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateSnapshotScheduleOutput {
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateVTLDeviceTypeInput {
#[serde(rename = "DeviceType")]
pub device_type: String,
#[serde(rename = "VTLDeviceARN")]
pub vtl_device_arn: String,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateVTLDeviceTypeOutput {
#[serde(rename = "VTLDeviceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vtl_device_arn: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VTLDevice {
#[serde(rename = "DeviceiSCSIAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub devicei_scsi_attributes: Option<DeviceiSCSIAttributes>,
#[serde(rename = "VTLDeviceARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vtl_device_arn: Option<String>,
#[serde(rename = "VTLDeviceProductIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vtl_device_product_identifier: Option<String>,
#[serde(rename = "VTLDeviceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vtl_device_type: Option<String>,
#[serde(rename = "VTLDeviceVendor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vtl_device_vendor: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VolumeInfo {
#[serde(rename = "GatewayARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_arn: Option<String>,
#[serde(rename = "GatewayId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub gateway_id: Option<String>,
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
#[serde(rename = "VolumeAttachmentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_attachment_status: Option<String>,
#[serde(rename = "VolumeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_id: Option<String>,
#[serde(rename = "VolumeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_size_in_bytes: Option<i64>,
#[serde(rename = "VolumeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_type: Option<String>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VolumeRecoveryPointInfo {
#[serde(rename = "VolumeARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_arn: Option<String>,
#[serde(rename = "VolumeRecoveryPointTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_recovery_point_time: Option<String>,
#[serde(rename = "VolumeSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_size_in_bytes: Option<i64>,
#[serde(rename = "VolumeUsageInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub volume_usage_in_bytes: Option<i64>,
}
#[derive(Default, Debug, Clone, PartialEq, Deserialize)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VolumeiSCSIAttributes {
#[serde(rename = "ChapEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub chap_enabled: Option<bool>,
#[serde(rename = "LunNumber")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lun_number: Option<i64>,
#[serde(rename = "NetworkInterfaceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface_id: Option<String>,
#[serde(rename = "NetworkInterfacePort")]
#[serde(skip_serializing_if = "Option::is_none")]
pub network_interface_port: Option<i64>,
#[serde(rename = "TargetARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum ActivateGatewayError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ActivateGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ActivateGatewayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ActivateGatewayError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ActivateGatewayError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ActivateGatewayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ActivateGatewayError::InternalServerError(ref cause) => write!(f, "{}", cause),
ActivateGatewayError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ActivateGatewayError {}
#[derive(Debug, PartialEq)]
pub enum AddCacheError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl AddCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddCacheError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(AddCacheError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(AddCacheError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddCacheError::InternalServerError(ref cause) => write!(f, "{}", cause),
AddCacheError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddCacheError {}
#[derive(Debug, PartialEq)]
pub enum AddTagsToResourceError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl AddTagsToResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddTagsToResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(AddTagsToResourceError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(AddTagsToResourceError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddTagsToResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddTagsToResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
AddTagsToResourceError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddTagsToResourceError {}
#[derive(Debug, PartialEq)]
pub enum AddUploadBufferError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl AddUploadBufferError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddUploadBufferError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(AddUploadBufferError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(AddUploadBufferError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddUploadBufferError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddUploadBufferError::InternalServerError(ref cause) => write!(f, "{}", cause),
AddUploadBufferError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddUploadBufferError {}
#[derive(Debug, PartialEq)]
pub enum AddWorkingStorageError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl AddWorkingStorageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddWorkingStorageError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(AddWorkingStorageError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(AddWorkingStorageError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddWorkingStorageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddWorkingStorageError::InternalServerError(ref cause) => write!(f, "{}", cause),
AddWorkingStorageError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddWorkingStorageError {}
#[derive(Debug, PartialEq)]
pub enum AssignTapePoolError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl AssignTapePoolError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AssignTapePoolError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(AssignTapePoolError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(AssignTapePoolError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssignTapePoolError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssignTapePoolError::InternalServerError(ref cause) => write!(f, "{}", cause),
AssignTapePoolError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssignTapePoolError {}
#[derive(Debug, PartialEq)]
pub enum AttachVolumeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl AttachVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachVolumeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(AttachVolumeError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(AttachVolumeError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachVolumeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachVolumeError::InternalServerError(ref cause) => write!(f, "{}", cause),
AttachVolumeError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AttachVolumeError {}
#[derive(Debug, PartialEq)]
pub enum CancelArchivalError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl CancelArchivalError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelArchivalError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CancelArchivalError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(CancelArchivalError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelArchivalError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelArchivalError::InternalServerError(ref cause) => write!(f, "{}", cause),
CancelArchivalError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelArchivalError {}
#[derive(Debug, PartialEq)]
pub enum CancelRetrievalError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl CancelRetrievalError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CancelRetrievalError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CancelRetrievalError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(CancelRetrievalError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CancelRetrievalError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CancelRetrievalError::InternalServerError(ref cause) => write!(f, "{}", cause),
CancelRetrievalError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CancelRetrievalError {}
#[derive(Debug, PartialEq)]
pub enum CreateCachediSCSIVolumeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl CreateCachediSCSIVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCachediSCSIVolumeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CreateCachediSCSIVolumeError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
CreateCachediSCSIVolumeError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCachediSCSIVolumeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCachediSCSIVolumeError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateCachediSCSIVolumeError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateCachediSCSIVolumeError {}
#[derive(Debug, PartialEq)]
pub enum CreateNFSFileShareError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl CreateNFSFileShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateNFSFileShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CreateNFSFileShareError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(CreateNFSFileShareError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateNFSFileShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateNFSFileShareError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateNFSFileShareError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateNFSFileShareError {}
#[derive(Debug, PartialEq)]
pub enum CreateSMBFileShareError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl CreateSMBFileShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSMBFileShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CreateSMBFileShareError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(CreateSMBFileShareError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSMBFileShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSMBFileShareError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateSMBFileShareError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSMBFileShareError {}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotError {
InternalServerError(String),
InvalidGatewayRequest(String),
ServiceUnavailableError(String),
}
impl CreateSnapshotError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSnapshotError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CreateSnapshotError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(CreateSnapshotError::InvalidGatewayRequest(
err.msg,
))
}
"ServiceUnavailableError" => {
return RusotoError::Service(CreateSnapshotError::ServiceUnavailableError(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSnapshotError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSnapshotError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
CreateSnapshotError::ServiceUnavailableError(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSnapshotError {}
#[derive(Debug, PartialEq)]
pub enum CreateSnapshotFromVolumeRecoveryPointError {
InternalServerError(String),
InvalidGatewayRequest(String),
ServiceUnavailableError(String),
}
impl CreateSnapshotFromVolumeRecoveryPointError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateSnapshotFromVolumeRecoveryPointError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
CreateSnapshotFromVolumeRecoveryPointError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
CreateSnapshotFromVolumeRecoveryPointError::InvalidGatewayRequest(err.msg),
)
}
"ServiceUnavailableError" => {
return RusotoError::Service(
CreateSnapshotFromVolumeRecoveryPointError::ServiceUnavailableError(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSnapshotFromVolumeRecoveryPointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSnapshotFromVolumeRecoveryPointError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotFromVolumeRecoveryPointError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
CreateSnapshotFromVolumeRecoveryPointError::ServiceUnavailableError(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateSnapshotFromVolumeRecoveryPointError {}
#[derive(Debug, PartialEq)]
pub enum CreateStorediSCSIVolumeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl CreateStorediSCSIVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateStorediSCSIVolumeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CreateStorediSCSIVolumeError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
CreateStorediSCSIVolumeError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateStorediSCSIVolumeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateStorediSCSIVolumeError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateStorediSCSIVolumeError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateStorediSCSIVolumeError {}
#[derive(Debug, PartialEq)]
pub enum CreateTapeWithBarcodeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl CreateTapeWithBarcodeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTapeWithBarcodeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CreateTapeWithBarcodeError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(CreateTapeWithBarcodeError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTapeWithBarcodeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTapeWithBarcodeError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateTapeWithBarcodeError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTapeWithBarcodeError {}
#[derive(Debug, PartialEq)]
pub enum CreateTapesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl CreateTapesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTapesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(CreateTapesError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(CreateTapesError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTapesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTapesError::InternalServerError(ref cause) => write!(f, "{}", cause),
CreateTapesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTapesError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAutomaticTapeCreationPolicyError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteAutomaticTapeCreationPolicyError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteAutomaticTapeCreationPolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DeleteAutomaticTapeCreationPolicyError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DeleteAutomaticTapeCreationPolicyError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAutomaticTapeCreationPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAutomaticTapeCreationPolicyError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DeleteAutomaticTapeCreationPolicyError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteAutomaticTapeCreationPolicyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBandwidthRateLimitError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteBandwidthRateLimitError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteBandwidthRateLimitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DeleteBandwidthRateLimitError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DeleteBandwidthRateLimitError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBandwidthRateLimitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBandwidthRateLimitError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteBandwidthRateLimitError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteBandwidthRateLimitError {}
#[derive(Debug, PartialEq)]
pub enum DeleteChapCredentialsError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteChapCredentialsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteChapCredentialsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DeleteChapCredentialsError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DeleteChapCredentialsError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteChapCredentialsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteChapCredentialsError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteChapCredentialsError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteChapCredentialsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFileShareError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteFileShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFileShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DeleteFileShareError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DeleteFileShareError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFileShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFileShareError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteFileShareError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFileShareError {}
#[derive(Debug, PartialEq)]
pub enum DeleteGatewayError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteGatewayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DeleteGatewayError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DeleteGatewayError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteGatewayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteGatewayError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteGatewayError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteGatewayError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSnapshotScheduleError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteSnapshotScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSnapshotScheduleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DeleteSnapshotScheduleError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DeleteSnapshotScheduleError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSnapshotScheduleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSnapshotScheduleError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteSnapshotScheduleError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSnapshotScheduleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTapeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteTapeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTapeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DeleteTapeError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DeleteTapeError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTapeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTapeError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteTapeError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTapeError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTapeArchiveError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteTapeArchiveError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTapeArchiveError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DeleteTapeArchiveError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DeleteTapeArchiveError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTapeArchiveError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTapeArchiveError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteTapeArchiveError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTapeArchiveError {}
#[derive(Debug, PartialEq)]
pub enum DeleteVolumeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DeleteVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVolumeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DeleteVolumeError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DeleteVolumeError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteVolumeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteVolumeError::InternalServerError(ref cause) => write!(f, "{}", cause),
DeleteVolumeError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteVolumeError {}
#[derive(Debug, PartialEq)]
pub enum DescribeAvailabilityMonitorTestError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeAvailabilityMonitorTestError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeAvailabilityMonitorTestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DescribeAvailabilityMonitorTestError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeAvailabilityMonitorTestError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeAvailabilityMonitorTestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeAvailabilityMonitorTestError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeAvailabilityMonitorTestError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeAvailabilityMonitorTestError {}
#[derive(Debug, PartialEq)]
pub enum DescribeBandwidthRateLimitError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeBandwidthRateLimitError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeBandwidthRateLimitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DescribeBandwidthRateLimitError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeBandwidthRateLimitError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeBandwidthRateLimitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeBandwidthRateLimitError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeBandwidthRateLimitError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeBandwidthRateLimitError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCacheError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCacheError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeCacheError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DescribeCacheError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCacheError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeCacheError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeCacheError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCachediSCSIVolumesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeCachediSCSIVolumesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeCachediSCSIVolumesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DescribeCachediSCSIVolumesError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeCachediSCSIVolumesError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCachediSCSIVolumesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCachediSCSIVolumesError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeCachediSCSIVolumesError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeCachediSCSIVolumesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeChapCredentialsError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeChapCredentialsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeChapCredentialsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeChapCredentialsError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeChapCredentialsError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeChapCredentialsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeChapCredentialsError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeChapCredentialsError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeChapCredentialsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeGatewayInformationError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeGatewayInformationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeGatewayInformationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DescribeGatewayInformationError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeGatewayInformationError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeGatewayInformationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeGatewayInformationError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeGatewayInformationError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeGatewayInformationError {}
#[derive(Debug, PartialEq)]
pub enum DescribeMaintenanceStartTimeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeMaintenanceStartTimeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeMaintenanceStartTimeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DescribeMaintenanceStartTimeError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeMaintenanceStartTimeError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeMaintenanceStartTimeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeMaintenanceStartTimeError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeMaintenanceStartTimeError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeMaintenanceStartTimeError {}
#[derive(Debug, PartialEq)]
pub enum DescribeNFSFileSharesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeNFSFileSharesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeNFSFileSharesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeNFSFileSharesError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DescribeNFSFileSharesError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeNFSFileSharesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeNFSFileSharesError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeNFSFileSharesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeNFSFileSharesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSMBFileSharesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeSMBFileSharesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSMBFileSharesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeSMBFileSharesError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DescribeSMBFileSharesError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSMBFileSharesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSMBFileSharesError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeSMBFileSharesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSMBFileSharesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSMBSettingsError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeSMBSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSMBSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeSMBSettingsError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DescribeSMBSettingsError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSMBSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSMBSettingsError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeSMBSettingsError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeSMBSettingsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeSnapshotScheduleError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeSnapshotScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeSnapshotScheduleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DescribeSnapshotScheduleError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeSnapshotScheduleError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeSnapshotScheduleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeSnapshotScheduleError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeSnapshotScheduleError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeSnapshotScheduleError {}
#[derive(Debug, PartialEq)]
pub enum DescribeStorediSCSIVolumesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeStorediSCSIVolumesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeStorediSCSIVolumesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DescribeStorediSCSIVolumesError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeStorediSCSIVolumesError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeStorediSCSIVolumesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeStorediSCSIVolumesError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeStorediSCSIVolumesError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeStorediSCSIVolumesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTapeArchivesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeTapeArchivesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTapeArchivesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeTapeArchivesError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DescribeTapeArchivesError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTapeArchivesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTapeArchivesError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeTapeArchivesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTapeArchivesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTapeRecoveryPointsError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeTapeRecoveryPointsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeTapeRecoveryPointsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
DescribeTapeRecoveryPointsError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeTapeRecoveryPointsError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTapeRecoveryPointsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTapeRecoveryPointsError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
DescribeTapeRecoveryPointsError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeTapeRecoveryPointsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTapesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeTapesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTapesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeTapesError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DescribeTapesError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTapesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTapesError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeTapesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTapesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeUploadBufferError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeUploadBufferError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeUploadBufferError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeUploadBufferError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DescribeUploadBufferError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeUploadBufferError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeUploadBufferError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeUploadBufferError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeUploadBufferError {}
#[derive(Debug, PartialEq)]
pub enum DescribeVTLDevicesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeVTLDevicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeVTLDevicesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeVTLDevicesError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DescribeVTLDevicesError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeVTLDevicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeVTLDevicesError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeVTLDevicesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeVTLDevicesError {}
#[derive(Debug, PartialEq)]
pub enum DescribeWorkingStorageError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DescribeWorkingStorageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeWorkingStorageError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DescribeWorkingStorageError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
DescribeWorkingStorageError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeWorkingStorageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeWorkingStorageError::InternalServerError(ref cause) => write!(f, "{}", cause),
DescribeWorkingStorageError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeWorkingStorageError {}
#[derive(Debug, PartialEq)]
pub enum DetachVolumeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DetachVolumeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachVolumeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DetachVolumeError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DetachVolumeError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachVolumeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachVolumeError::InternalServerError(ref cause) => write!(f, "{}", cause),
DetachVolumeError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetachVolumeError {}
#[derive(Debug, PartialEq)]
pub enum DisableGatewayError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl DisableGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableGatewayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(DisableGatewayError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(DisableGatewayError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisableGatewayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableGatewayError::InternalServerError(ref cause) => write!(f, "{}", cause),
DisableGatewayError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableGatewayError {}
#[derive(Debug, PartialEq)]
pub enum JoinDomainError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl JoinDomainError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<JoinDomainError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(JoinDomainError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(JoinDomainError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for JoinDomainError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
JoinDomainError::InternalServerError(ref cause) => write!(f, "{}", cause),
JoinDomainError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for JoinDomainError {}
#[derive(Debug, PartialEq)]
pub enum ListAutomaticTapeCreationPoliciesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListAutomaticTapeCreationPoliciesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListAutomaticTapeCreationPoliciesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
ListAutomaticTapeCreationPoliciesError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
ListAutomaticTapeCreationPoliciesError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAutomaticTapeCreationPoliciesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAutomaticTapeCreationPoliciesError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
ListAutomaticTapeCreationPoliciesError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListAutomaticTapeCreationPoliciesError {}
#[derive(Debug, PartialEq)]
pub enum ListFileSharesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListFileSharesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFileSharesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ListFileSharesError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ListFileSharesError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFileSharesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFileSharesError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListFileSharesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFileSharesError {}
#[derive(Debug, PartialEq)]
pub enum ListGatewaysError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListGatewaysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListGatewaysError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ListGatewaysError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ListGatewaysError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGatewaysError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGatewaysError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListGatewaysError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListGatewaysError {}
#[derive(Debug, PartialEq)]
pub enum ListLocalDisksError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListLocalDisksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLocalDisksError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ListLocalDisksError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ListLocalDisksError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLocalDisksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLocalDisksError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListLocalDisksError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLocalDisksError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ListTagsForResourceError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListTapesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListTapesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTapesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ListTapesError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ListTapesError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTapesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTapesError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListTapesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTapesError {}
#[derive(Debug, PartialEq)]
pub enum ListVolumeInitiatorsError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListVolumeInitiatorsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListVolumeInitiatorsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ListVolumeInitiatorsError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ListVolumeInitiatorsError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListVolumeInitiatorsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListVolumeInitiatorsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListVolumeInitiatorsError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListVolumeInitiatorsError {}
#[derive(Debug, PartialEq)]
pub enum ListVolumeRecoveryPointsError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListVolumeRecoveryPointsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListVolumeRecoveryPointsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
ListVolumeRecoveryPointsError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
ListVolumeRecoveryPointsError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListVolumeRecoveryPointsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListVolumeRecoveryPointsError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListVolumeRecoveryPointsError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListVolumeRecoveryPointsError {}
#[derive(Debug, PartialEq)]
pub enum ListVolumesError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ListVolumesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListVolumesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ListVolumesError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ListVolumesError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListVolumesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListVolumesError::InternalServerError(ref cause) => write!(f, "{}", cause),
ListVolumesError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListVolumesError {}
#[derive(Debug, PartialEq)]
pub enum NotifyWhenUploadedError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl NotifyWhenUploadedError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<NotifyWhenUploadedError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(NotifyWhenUploadedError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(NotifyWhenUploadedError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for NotifyWhenUploadedError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
NotifyWhenUploadedError::InternalServerError(ref cause) => write!(f, "{}", cause),
NotifyWhenUploadedError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for NotifyWhenUploadedError {}
#[derive(Debug, PartialEq)]
pub enum RefreshCacheError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl RefreshCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RefreshCacheError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(RefreshCacheError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(RefreshCacheError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RefreshCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RefreshCacheError::InternalServerError(ref cause) => write!(f, "{}", cause),
RefreshCacheError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RefreshCacheError {}
#[derive(Debug, PartialEq)]
pub enum RemoveTagsFromResourceError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl RemoveTagsFromResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveTagsFromResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(RemoveTagsFromResourceError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
RemoveTagsFromResourceError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveTagsFromResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveTagsFromResourceError::InternalServerError(ref cause) => write!(f, "{}", cause),
RemoveTagsFromResourceError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveTagsFromResourceError {}
#[derive(Debug, PartialEq)]
pub enum ResetCacheError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ResetCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ResetCacheError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ResetCacheError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ResetCacheError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ResetCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ResetCacheError::InternalServerError(ref cause) => write!(f, "{}", cause),
ResetCacheError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ResetCacheError {}
#[derive(Debug, PartialEq)]
pub enum RetrieveTapeArchiveError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl RetrieveTapeArchiveError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RetrieveTapeArchiveError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(RetrieveTapeArchiveError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(RetrieveTapeArchiveError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RetrieveTapeArchiveError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RetrieveTapeArchiveError::InternalServerError(ref cause) => write!(f, "{}", cause),
RetrieveTapeArchiveError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RetrieveTapeArchiveError {}
#[derive(Debug, PartialEq)]
pub enum RetrieveTapeRecoveryPointError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl RetrieveTapeRecoveryPointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RetrieveTapeRecoveryPointError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
RetrieveTapeRecoveryPointError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
RetrieveTapeRecoveryPointError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RetrieveTapeRecoveryPointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RetrieveTapeRecoveryPointError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
RetrieveTapeRecoveryPointError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for RetrieveTapeRecoveryPointError {}
#[derive(Debug, PartialEq)]
pub enum SetLocalConsolePasswordError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl SetLocalConsolePasswordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetLocalConsolePasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(SetLocalConsolePasswordError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
SetLocalConsolePasswordError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetLocalConsolePasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetLocalConsolePasswordError::InternalServerError(ref cause) => write!(f, "{}", cause),
SetLocalConsolePasswordError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for SetLocalConsolePasswordError {}
#[derive(Debug, PartialEq)]
pub enum SetSMBGuestPasswordError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl SetSMBGuestPasswordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SetSMBGuestPasswordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(SetSMBGuestPasswordError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(SetSMBGuestPasswordError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SetSMBGuestPasswordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SetSMBGuestPasswordError::InternalServerError(ref cause) => write!(f, "{}", cause),
SetSMBGuestPasswordError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SetSMBGuestPasswordError {}
#[derive(Debug, PartialEq)]
pub enum ShutdownGatewayError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl ShutdownGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ShutdownGatewayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(ShutdownGatewayError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(ShutdownGatewayError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ShutdownGatewayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ShutdownGatewayError::InternalServerError(ref cause) => write!(f, "{}", cause),
ShutdownGatewayError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ShutdownGatewayError {}
#[derive(Debug, PartialEq)]
pub enum StartAvailabilityMonitorTestError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl StartAvailabilityMonitorTestError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<StartAvailabilityMonitorTestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
StartAvailabilityMonitorTestError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
StartAvailabilityMonitorTestError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartAvailabilityMonitorTestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartAvailabilityMonitorTestError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
StartAvailabilityMonitorTestError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for StartAvailabilityMonitorTestError {}
#[derive(Debug, PartialEq)]
pub enum StartGatewayError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl StartGatewayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartGatewayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(StartGatewayError::InternalServerError(err.msg))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(StartGatewayError::InvalidGatewayRequest(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartGatewayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartGatewayError::InternalServerError(ref cause) => write!(f, "{}", cause),
StartGatewayError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartGatewayError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAutomaticTapeCreationPolicyError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateAutomaticTapeCreationPolicyError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateAutomaticTapeCreationPolicyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
UpdateAutomaticTapeCreationPolicyError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
UpdateAutomaticTapeCreationPolicyError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAutomaticTapeCreationPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAutomaticTapeCreationPolicyError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
UpdateAutomaticTapeCreationPolicyError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateAutomaticTapeCreationPolicyError {}
#[derive(Debug, PartialEq)]
pub enum UpdateBandwidthRateLimitError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateBandwidthRateLimitError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateBandwidthRateLimitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
UpdateBandwidthRateLimitError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
UpdateBandwidthRateLimitError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateBandwidthRateLimitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateBandwidthRateLimitError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateBandwidthRateLimitError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateBandwidthRateLimitError {}
#[derive(Debug, PartialEq)]
pub enum UpdateChapCredentialsError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateChapCredentialsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateChapCredentialsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(UpdateChapCredentialsError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(UpdateChapCredentialsError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateChapCredentialsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateChapCredentialsError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateChapCredentialsError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateChapCredentialsError {}
#[derive(Debug, PartialEq)]
pub enum UpdateGatewayInformationError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateGatewayInformationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateGatewayInformationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
UpdateGatewayInformationError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
UpdateGatewayInformationError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateGatewayInformationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateGatewayInformationError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateGatewayInformationError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateGatewayInformationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateGatewaySoftwareNowError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateGatewaySoftwareNowError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateGatewaySoftwareNowError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
UpdateGatewaySoftwareNowError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
UpdateGatewaySoftwareNowError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateGatewaySoftwareNowError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateGatewaySoftwareNowError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateGatewaySoftwareNowError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateGatewaySoftwareNowError {}
#[derive(Debug, PartialEq)]
pub enum UpdateMaintenanceStartTimeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateMaintenanceStartTimeError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateMaintenanceStartTimeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
UpdateMaintenanceStartTimeError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
UpdateMaintenanceStartTimeError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateMaintenanceStartTimeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateMaintenanceStartTimeError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
UpdateMaintenanceStartTimeError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateMaintenanceStartTimeError {}
#[derive(Debug, PartialEq)]
pub enum UpdateNFSFileShareError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateNFSFileShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateNFSFileShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(UpdateNFSFileShareError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(UpdateNFSFileShareError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateNFSFileShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateNFSFileShareError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateNFSFileShareError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateNFSFileShareError {}
#[derive(Debug, PartialEq)]
pub enum UpdateSMBFileShareError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateSMBFileShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateSMBFileShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(UpdateSMBFileShareError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(UpdateSMBFileShareError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateSMBFileShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateSMBFileShareError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateSMBFileShareError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateSMBFileShareError {}
#[derive(Debug, PartialEq)]
pub enum UpdateSMBSecurityStrategyError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateSMBSecurityStrategyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateSMBSecurityStrategyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(
UpdateSMBSecurityStrategyError::InternalServerError(err.msg),
)
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
UpdateSMBSecurityStrategyError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateSMBSecurityStrategyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateSMBSecurityStrategyError::InternalServerError(ref cause) => {
write!(f, "{}", cause)
}
UpdateSMBSecurityStrategyError::InvalidGatewayRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateSMBSecurityStrategyError {}
#[derive(Debug, PartialEq)]
pub enum UpdateSnapshotScheduleError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateSnapshotScheduleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateSnapshotScheduleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(UpdateSnapshotScheduleError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(
UpdateSnapshotScheduleError::InvalidGatewayRequest(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateSnapshotScheduleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateSnapshotScheduleError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateSnapshotScheduleError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateSnapshotScheduleError {}
#[derive(Debug, PartialEq)]
pub enum UpdateVTLDeviceTypeError {
InternalServerError(String),
InvalidGatewayRequest(String),
}
impl UpdateVTLDeviceTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateVTLDeviceTypeError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InternalServerError" => {
return RusotoError::Service(UpdateVTLDeviceTypeError::InternalServerError(
err.msg,
))
}
"InvalidGatewayRequestException" => {
return RusotoError::Service(UpdateVTLDeviceTypeError::InvalidGatewayRequest(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateVTLDeviceTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateVTLDeviceTypeError::InternalServerError(ref cause) => write!(f, "{}", cause),
UpdateVTLDeviceTypeError::InvalidGatewayRequest(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateVTLDeviceTypeError {}
#[async_trait]
pub trait StorageGateway {
async fn activate_gateway(
&self,
input: ActivateGatewayInput,
) -> Result<ActivateGatewayOutput, RusotoError<ActivateGatewayError>>;
async fn add_cache(
&self,
input: AddCacheInput,
) -> Result<AddCacheOutput, RusotoError<AddCacheError>>;
async fn add_tags_to_resource(
&self,
input: AddTagsToResourceInput,
) -> Result<AddTagsToResourceOutput, RusotoError<AddTagsToResourceError>>;
async fn add_upload_buffer(
&self,
input: AddUploadBufferInput,
) -> Result<AddUploadBufferOutput, RusotoError<AddUploadBufferError>>;
async fn add_working_storage(
&self,
input: AddWorkingStorageInput,
) -> Result<AddWorkingStorageOutput, RusotoError<AddWorkingStorageError>>;
async fn assign_tape_pool(
&self,
input: AssignTapePoolInput,
) -> Result<AssignTapePoolOutput, RusotoError<AssignTapePoolError>>;
async fn attach_volume(
&self,
input: AttachVolumeInput,
) -> Result<AttachVolumeOutput, RusotoError<AttachVolumeError>>;
async fn cancel_archival(
&self,
input: CancelArchivalInput,
) -> Result<CancelArchivalOutput, RusotoError<CancelArchivalError>>;
async fn cancel_retrieval(
&self,
input: CancelRetrievalInput,
) -> Result<CancelRetrievalOutput, RusotoError<CancelRetrievalError>>;
async fn create_cachedi_scsi_volume(
&self,
input: CreateCachediSCSIVolumeInput,
) -> Result<CreateCachediSCSIVolumeOutput, RusotoError<CreateCachediSCSIVolumeError>>;
async fn create_nfs_file_share(
&self,
input: CreateNFSFileShareInput,
) -> Result<CreateNFSFileShareOutput, RusotoError<CreateNFSFileShareError>>;
async fn create_smb_file_share(
&self,
input: CreateSMBFileShareInput,
) -> Result<CreateSMBFileShareOutput, RusotoError<CreateSMBFileShareError>>;
async fn create_snapshot(
&self,
input: CreateSnapshotInput,
) -> Result<CreateSnapshotOutput, RusotoError<CreateSnapshotError>>;
async fn create_snapshot_from_volume_recovery_point(
&self,
input: CreateSnapshotFromVolumeRecoveryPointInput,
) -> Result<
CreateSnapshotFromVolumeRecoveryPointOutput,
RusotoError<CreateSnapshotFromVolumeRecoveryPointError>,
>;
async fn create_storedi_scsi_volume(
&self,
input: CreateStorediSCSIVolumeInput,
) -> Result<CreateStorediSCSIVolumeOutput, RusotoError<CreateStorediSCSIVolumeError>>;
async fn create_tape_with_barcode(
&self,
input: CreateTapeWithBarcodeInput,
) -> Result<CreateTapeWithBarcodeOutput, RusotoError<CreateTapeWithBarcodeError>>;
async fn create_tapes(
&self,
input: CreateTapesInput,
) -> Result<CreateTapesOutput, RusotoError<CreateTapesError>>;
async fn delete_automatic_tape_creation_policy(
&self,
input: DeleteAutomaticTapeCreationPolicyInput,
) -> Result<
DeleteAutomaticTapeCreationPolicyOutput,
RusotoError<DeleteAutomaticTapeCreationPolicyError>,
>;
async fn delete_bandwidth_rate_limit(
&self,
input: DeleteBandwidthRateLimitInput,
) -> Result<DeleteBandwidthRateLimitOutput, RusotoError<DeleteBandwidthRateLimitError>>;
async fn delete_chap_credentials(
&self,
input: DeleteChapCredentialsInput,
) -> Result<DeleteChapCredentialsOutput, RusotoError<DeleteChapCredentialsError>>;
async fn delete_file_share(
&self,
input: DeleteFileShareInput,
) -> Result<DeleteFileShareOutput, RusotoError<DeleteFileShareError>>;
async fn delete_gateway(
&self,
input: DeleteGatewayInput,
) -> Result<DeleteGatewayOutput, RusotoError<DeleteGatewayError>>;
async fn delete_snapshot_schedule(
&self,
input: DeleteSnapshotScheduleInput,
) -> Result<DeleteSnapshotScheduleOutput, RusotoError<DeleteSnapshotScheduleError>>;
async fn delete_tape(
&self,
input: DeleteTapeInput,
) -> Result<DeleteTapeOutput, RusotoError<DeleteTapeError>>;
async fn delete_tape_archive(
&self,
input: DeleteTapeArchiveInput,
) -> Result<DeleteTapeArchiveOutput, RusotoError<DeleteTapeArchiveError>>;
async fn delete_volume(
&self,
input: DeleteVolumeInput,
) -> Result<DeleteVolumeOutput, RusotoError<DeleteVolumeError>>;
async fn describe_availability_monitor_test(
&self,
input: DescribeAvailabilityMonitorTestInput,
) -> Result<
DescribeAvailabilityMonitorTestOutput,
RusotoError<DescribeAvailabilityMonitorTestError>,
>;
async fn describe_bandwidth_rate_limit(
&self,
input: DescribeBandwidthRateLimitInput,
) -> Result<DescribeBandwidthRateLimitOutput, RusotoError<DescribeBandwidthRateLimitError>>;
async fn describe_cache(
&self,
input: DescribeCacheInput,
) -> Result<DescribeCacheOutput, RusotoError<DescribeCacheError>>;
async fn describe_cachedi_scsi_volumes(
&self,
input: DescribeCachediSCSIVolumesInput,
) -> Result<DescribeCachediSCSIVolumesOutput, RusotoError<DescribeCachediSCSIVolumesError>>;
async fn describe_chap_credentials(
&self,
input: DescribeChapCredentialsInput,
) -> Result<DescribeChapCredentialsOutput, RusotoError<DescribeChapCredentialsError>>;
async fn describe_gateway_information(
&self,
input: DescribeGatewayInformationInput,
) -> Result<DescribeGatewayInformationOutput, RusotoError<DescribeGatewayInformationError>>;
async fn describe_maintenance_start_time(
&self,
input: DescribeMaintenanceStartTimeInput,
) -> Result<DescribeMaintenanceStartTimeOutput, RusotoError<DescribeMaintenanceStartTimeError>>;
async fn describe_nfs_file_shares(
&self,
input: DescribeNFSFileSharesInput,
) -> Result<DescribeNFSFileSharesOutput, RusotoError<DescribeNFSFileSharesError>>;
async fn describe_smb_file_shares(
&self,
input: DescribeSMBFileSharesInput,
) -> Result<DescribeSMBFileSharesOutput, RusotoError<DescribeSMBFileSharesError>>;
async fn describe_smb_settings(
&self,
input: DescribeSMBSettingsInput,
) -> Result<DescribeSMBSettingsOutput, RusotoError<DescribeSMBSettingsError>>;
async fn describe_snapshot_schedule(
&self,
input: DescribeSnapshotScheduleInput,
) -> Result<DescribeSnapshotScheduleOutput, RusotoError<DescribeSnapshotScheduleError>>;
async fn describe_storedi_scsi_volumes(
&self,
input: DescribeStorediSCSIVolumesInput,
) -> Result<DescribeStorediSCSIVolumesOutput, RusotoError<DescribeStorediSCSIVolumesError>>;
async fn describe_tape_archives(
&self,
input: DescribeTapeArchivesInput,
) -> Result<DescribeTapeArchivesOutput, RusotoError<DescribeTapeArchivesError>>;
async fn describe_tape_recovery_points(
&self,
input: DescribeTapeRecoveryPointsInput,
) -> Result<DescribeTapeRecoveryPointsOutput, RusotoError<DescribeTapeRecoveryPointsError>>;
async fn describe_tapes(
&self,
input: DescribeTapesInput,
) -> Result<DescribeTapesOutput, RusotoError<DescribeTapesError>>;
async fn describe_upload_buffer(
&self,
input: DescribeUploadBufferInput,
) -> Result<DescribeUploadBufferOutput, RusotoError<DescribeUploadBufferError>>;
async fn describe_vtl_devices(
&self,
input: DescribeVTLDevicesInput,
) -> Result<DescribeVTLDevicesOutput, RusotoError<DescribeVTLDevicesError>>;
async fn describe_working_storage(
&self,
input: DescribeWorkingStorageInput,
) -> Result<DescribeWorkingStorageOutput, RusotoError<DescribeWorkingStorageError>>;
async fn detach_volume(
&self,
input: DetachVolumeInput,
) -> Result<DetachVolumeOutput, RusotoError<DetachVolumeError>>;
async fn disable_gateway(
&self,
input: DisableGatewayInput,
) -> Result<DisableGatewayOutput, RusotoError<DisableGatewayError>>;
async fn join_domain(
&self,
input: JoinDomainInput,
) -> Result<JoinDomainOutput, RusotoError<JoinDomainError>>;
async fn list_automatic_tape_creation_policies(
&self,
input: ListAutomaticTapeCreationPoliciesInput,
) -> Result<
ListAutomaticTapeCreationPoliciesOutput,
RusotoError<ListAutomaticTapeCreationPoliciesError>,
>;
async fn list_file_shares(
&self,
input: ListFileSharesInput,
) -> Result<ListFileSharesOutput, RusotoError<ListFileSharesError>>;
async fn list_gateways(
&self,
input: ListGatewaysInput,
) -> Result<ListGatewaysOutput, RusotoError<ListGatewaysError>>;
async fn list_local_disks(
&self,
input: ListLocalDisksInput,
) -> Result<ListLocalDisksOutput, RusotoError<ListLocalDisksError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>>;
async fn list_tapes(
&self,
input: ListTapesInput,
) -> Result<ListTapesOutput, RusotoError<ListTapesError>>;
async fn list_volume_initiators(
&self,
input: ListVolumeInitiatorsInput,
) -> Result<ListVolumeInitiatorsOutput, RusotoError<ListVolumeInitiatorsError>>;
async fn list_volume_recovery_points(
&self,
input: ListVolumeRecoveryPointsInput,
) -> Result<ListVolumeRecoveryPointsOutput, RusotoError<ListVolumeRecoveryPointsError>>;
async fn list_volumes(
&self,
input: ListVolumesInput,
) -> Result<ListVolumesOutput, RusotoError<ListVolumesError>>;
async fn notify_when_uploaded(
&self,
input: NotifyWhenUploadedInput,
) -> Result<NotifyWhenUploadedOutput, RusotoError<NotifyWhenUploadedError>>;
async fn refresh_cache(
&self,
input: RefreshCacheInput,
) -> Result<RefreshCacheOutput, RusotoError<RefreshCacheError>>;
async fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceInput,
) -> Result<RemoveTagsFromResourceOutput, RusotoError<RemoveTagsFromResourceError>>;
async fn reset_cache(
&self,
input: ResetCacheInput,
) -> Result<ResetCacheOutput, RusotoError<ResetCacheError>>;
async fn retrieve_tape_archive(
&self,
input: RetrieveTapeArchiveInput,
) -> Result<RetrieveTapeArchiveOutput, RusotoError<RetrieveTapeArchiveError>>;
async fn retrieve_tape_recovery_point(
&self,
input: RetrieveTapeRecoveryPointInput,
) -> Result<RetrieveTapeRecoveryPointOutput, RusotoError<RetrieveTapeRecoveryPointError>>;
async fn set_local_console_password(
&self,
input: SetLocalConsolePasswordInput,
) -> Result<SetLocalConsolePasswordOutput, RusotoError<SetLocalConsolePasswordError>>;
async fn set_smb_guest_password(
&self,
input: SetSMBGuestPasswordInput,
) -> Result<SetSMBGuestPasswordOutput, RusotoError<SetSMBGuestPasswordError>>;
async fn shutdown_gateway(
&self,
input: ShutdownGatewayInput,
) -> Result<ShutdownGatewayOutput, RusotoError<ShutdownGatewayError>>;
async fn start_availability_monitor_test(
&self,
input: StartAvailabilityMonitorTestInput,
) -> Result<StartAvailabilityMonitorTestOutput, RusotoError<StartAvailabilityMonitorTestError>>;
async fn start_gateway(
&self,
input: StartGatewayInput,
) -> Result<StartGatewayOutput, RusotoError<StartGatewayError>>;
async fn update_automatic_tape_creation_policy(
&self,
input: UpdateAutomaticTapeCreationPolicyInput,
) -> Result<
UpdateAutomaticTapeCreationPolicyOutput,
RusotoError<UpdateAutomaticTapeCreationPolicyError>,
>;
async fn update_bandwidth_rate_limit(
&self,
input: UpdateBandwidthRateLimitInput,
) -> Result<UpdateBandwidthRateLimitOutput, RusotoError<UpdateBandwidthRateLimitError>>;
async fn update_chap_credentials(
&self,
input: UpdateChapCredentialsInput,
) -> Result<UpdateChapCredentialsOutput, RusotoError<UpdateChapCredentialsError>>;
async fn update_gateway_information(
&self,
input: UpdateGatewayInformationInput,
) -> Result<UpdateGatewayInformationOutput, RusotoError<UpdateGatewayInformationError>>;
async fn update_gateway_software_now(
&self,
input: UpdateGatewaySoftwareNowInput,
) -> Result<UpdateGatewaySoftwareNowOutput, RusotoError<UpdateGatewaySoftwareNowError>>;
async fn update_maintenance_start_time(
&self,
input: UpdateMaintenanceStartTimeInput,
) -> Result<UpdateMaintenanceStartTimeOutput, RusotoError<UpdateMaintenanceStartTimeError>>;
async fn update_nfs_file_share(
&self,
input: UpdateNFSFileShareInput,
) -> Result<UpdateNFSFileShareOutput, RusotoError<UpdateNFSFileShareError>>;
async fn update_smb_file_share(
&self,
input: UpdateSMBFileShareInput,
) -> Result<UpdateSMBFileShareOutput, RusotoError<UpdateSMBFileShareError>>;
async fn update_smb_security_strategy(
&self,
input: UpdateSMBSecurityStrategyInput,
) -> Result<UpdateSMBSecurityStrategyOutput, RusotoError<UpdateSMBSecurityStrategyError>>;
async fn update_snapshot_schedule(
&self,
input: UpdateSnapshotScheduleInput,
) -> Result<UpdateSnapshotScheduleOutput, RusotoError<UpdateSnapshotScheduleError>>;
async fn update_vtl_device_type(
&self,
input: UpdateVTLDeviceTypeInput,
) -> Result<UpdateVTLDeviceTypeOutput, RusotoError<UpdateVTLDeviceTypeError>>;
}
#[derive(Clone)]
pub struct StorageGatewayClient {
client: Client,
region: region::Region,
}
impl StorageGatewayClient {
pub fn new(region: region::Region) -> StorageGatewayClient {
StorageGatewayClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> StorageGatewayClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
StorageGatewayClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> StorageGatewayClient {
StorageGatewayClient { client, region }
}
}
#[async_trait]
impl StorageGateway for StorageGatewayClient {
async fn activate_gateway(
&self,
input: ActivateGatewayInput,
) -> Result<ActivateGatewayOutput, RusotoError<ActivateGatewayError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.ActivateGateway");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ActivateGatewayOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ActivateGatewayError::from_response(response))
}
}
async fn add_cache(
&self,
input: AddCacheInput,
) -> Result<AddCacheOutput, RusotoError<AddCacheError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.AddCache");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AddCacheOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddCacheError::from_response(response))
}
}
async fn add_tags_to_resource(
&self,
input: AddTagsToResourceInput,
) -> Result<AddTagsToResourceOutput, RusotoError<AddTagsToResourceError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.AddTagsToResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AddTagsToResourceOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddTagsToResourceError::from_response(response))
}
}
async fn add_upload_buffer(
&self,
input: AddUploadBufferInput,
) -> Result<AddUploadBufferOutput, RusotoError<AddUploadBufferError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.AddUploadBuffer");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AddUploadBufferOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddUploadBufferError::from_response(response))
}
}
async fn add_working_storage(
&self,
input: AddWorkingStorageInput,
) -> Result<AddWorkingStorageOutput, RusotoError<AddWorkingStorageError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.AddWorkingStorage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AddWorkingStorageOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AddWorkingStorageError::from_response(response))
}
}
async fn assign_tape_pool(
&self,
input: AssignTapePoolInput,
) -> Result<AssignTapePoolOutput, RusotoError<AssignTapePoolError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.AssignTapePool");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AssignTapePoolOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AssignTapePoolError::from_response(response))
}
}
async fn attach_volume(
&self,
input: AttachVolumeInput,
) -> Result<AttachVolumeOutput, RusotoError<AttachVolumeError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.AttachVolume");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AttachVolumeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(AttachVolumeError::from_response(response))
}
}
async fn cancel_archival(
&self,
input: CancelArchivalInput,
) -> Result<CancelArchivalOutput, RusotoError<CancelArchivalError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.CancelArchival");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CancelArchivalOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CancelArchivalError::from_response(response))
}
}
async fn cancel_retrieval(
&self,
input: CancelRetrievalInput,
) -> Result<CancelRetrievalOutput, RusotoError<CancelRetrievalError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.CancelRetrieval");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CancelRetrievalOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CancelRetrievalError::from_response(response))
}
}
async fn create_cachedi_scsi_volume(
&self,
input: CreateCachediSCSIVolumeInput,
) -> Result<CreateCachediSCSIVolumeOutput, RusotoError<CreateCachediSCSIVolumeError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.CreateCachediSCSIVolume",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCachediSCSIVolumeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateCachediSCSIVolumeError::from_response(response))
}
}
async fn create_nfs_file_share(
&self,
input: CreateNFSFileShareInput,
) -> Result<CreateNFSFileShareOutput, RusotoError<CreateNFSFileShareError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.CreateNFSFileShare");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateNFSFileShareOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateNFSFileShareError::from_response(response))
}
}
async fn create_smb_file_share(
&self,
input: CreateSMBFileShareInput,
) -> Result<CreateSMBFileShareOutput, RusotoError<CreateSMBFileShareError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.CreateSMBFileShare");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSMBFileShareOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateSMBFileShareError::from_response(response))
}
}
async fn create_snapshot(
&self,
input: CreateSnapshotInput,
) -> Result<CreateSnapshotOutput, RusotoError<CreateSnapshotError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.CreateSnapshot");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateSnapshotOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateSnapshotError::from_response(response))
}
}
async fn create_snapshot_from_volume_recovery_point(
&self,
input: CreateSnapshotFromVolumeRecoveryPointInput,
) -> Result<
CreateSnapshotFromVolumeRecoveryPointOutput,
RusotoError<CreateSnapshotFromVolumeRecoveryPointError>,
> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.CreateSnapshotFromVolumeRecoveryPoint",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSnapshotFromVolumeRecoveryPointOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateSnapshotFromVolumeRecoveryPointError::from_response(
response,
))
}
}
async fn create_storedi_scsi_volume(
&self,
input: CreateStorediSCSIVolumeInput,
) -> Result<CreateStorediSCSIVolumeOutput, RusotoError<CreateStorediSCSIVolumeError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.CreateStorediSCSIVolume",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateStorediSCSIVolumeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateStorediSCSIVolumeError::from_response(response))
}
}
async fn create_tape_with_barcode(
&self,
input: CreateTapeWithBarcodeInput,
) -> Result<CreateTapeWithBarcodeOutput, RusotoError<CreateTapeWithBarcodeError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.CreateTapeWithBarcode",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateTapeWithBarcodeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateTapeWithBarcodeError::from_response(response))
}
}
async fn create_tapes(
&self,
input: CreateTapesInput,
) -> Result<CreateTapesOutput, RusotoError<CreateTapesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.CreateTapes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTapesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(CreateTapesError::from_response(response))
}
}
async fn delete_automatic_tape_creation_policy(
&self,
input: DeleteAutomaticTapeCreationPolicyInput,
) -> Result<
DeleteAutomaticTapeCreationPolicyOutput,
RusotoError<DeleteAutomaticTapeCreationPolicyError>,
> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DeleteAutomaticTapeCreationPolicy",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteAutomaticTapeCreationPolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteAutomaticTapeCreationPolicyError::from_response(
response,
))
}
}
async fn delete_bandwidth_rate_limit(
&self,
input: DeleteBandwidthRateLimitInput,
) -> Result<DeleteBandwidthRateLimitOutput, RusotoError<DeleteBandwidthRateLimitError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DeleteBandwidthRateLimit",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteBandwidthRateLimitOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteBandwidthRateLimitError::from_response(response))
}
}
async fn delete_chap_credentials(
&self,
input: DeleteChapCredentialsInput,
) -> Result<DeleteChapCredentialsOutput, RusotoError<DeleteChapCredentialsError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DeleteChapCredentials",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteChapCredentialsOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteChapCredentialsError::from_response(response))
}
}
async fn delete_file_share(
&self,
input: DeleteFileShareInput,
) -> Result<DeleteFileShareOutput, RusotoError<DeleteFileShareError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DeleteFileShare");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteFileShareOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFileShareError::from_response(response))
}
}
async fn delete_gateway(
&self,
input: DeleteGatewayInput,
) -> Result<DeleteGatewayOutput, RusotoError<DeleteGatewayError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DeleteGateway");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteGatewayOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteGatewayError::from_response(response))
}
}
async fn delete_snapshot_schedule(
&self,
input: DeleteSnapshotScheduleInput,
) -> Result<DeleteSnapshotScheduleOutput, RusotoError<DeleteSnapshotScheduleError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DeleteSnapshotSchedule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteSnapshotScheduleOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteSnapshotScheduleError::from_response(response))
}
}
async fn delete_tape(
&self,
input: DeleteTapeInput,
) -> Result<DeleteTapeOutput, RusotoError<DeleteTapeError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DeleteTape");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTapeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteTapeError::from_response(response))
}
}
async fn delete_tape_archive(
&self,
input: DeleteTapeArchiveInput,
) -> Result<DeleteTapeArchiveOutput, RusotoError<DeleteTapeArchiveError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DeleteTapeArchive");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTapeArchiveOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteTapeArchiveError::from_response(response))
}
}
async fn delete_volume(
&self,
input: DeleteVolumeInput,
) -> Result<DeleteVolumeOutput, RusotoError<DeleteVolumeError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DeleteVolume");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteVolumeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DeleteVolumeError::from_response(response))
}
}
async fn describe_availability_monitor_test(
&self,
input: DescribeAvailabilityMonitorTestInput,
) -> Result<
DescribeAvailabilityMonitorTestOutput,
RusotoError<DescribeAvailabilityMonitorTestError>,
> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeAvailabilityMonitorTest",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeAvailabilityMonitorTestOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeAvailabilityMonitorTestError::from_response(
response,
))
}
}
async fn describe_bandwidth_rate_limit(
&self,
input: DescribeBandwidthRateLimitInput,
) -> Result<DescribeBandwidthRateLimitOutput, RusotoError<DescribeBandwidthRateLimitError>>
{
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeBandwidthRateLimit",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeBandwidthRateLimitOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeBandwidthRateLimitError::from_response(response))
}
}
async fn describe_cache(
&self,
input: DescribeCacheInput,
) -> Result<DescribeCacheOutput, RusotoError<DescribeCacheError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DescribeCache");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeCacheOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeCacheError::from_response(response))
}
}
async fn describe_cachedi_scsi_volumes(
&self,
input: DescribeCachediSCSIVolumesInput,
) -> Result<DescribeCachediSCSIVolumesOutput, RusotoError<DescribeCachediSCSIVolumesError>>
{
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeCachediSCSIVolumes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCachediSCSIVolumesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeCachediSCSIVolumesError::from_response(response))
}
}
async fn describe_chap_credentials(
&self,
input: DescribeChapCredentialsInput,
) -> Result<DescribeChapCredentialsOutput, RusotoError<DescribeChapCredentialsError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeChapCredentials",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeChapCredentialsOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeChapCredentialsError::from_response(response))
}
}
async fn describe_gateway_information(
&self,
input: DescribeGatewayInformationInput,
) -> Result<DescribeGatewayInformationOutput, RusotoError<DescribeGatewayInformationError>>
{
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeGatewayInformation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeGatewayInformationOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeGatewayInformationError::from_response(response))
}
}
async fn describe_maintenance_start_time(
&self,
input: DescribeMaintenanceStartTimeInput,
) -> Result<DescribeMaintenanceStartTimeOutput, RusotoError<DescribeMaintenanceStartTimeError>>
{
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeMaintenanceStartTime",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeMaintenanceStartTimeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeMaintenanceStartTimeError::from_response(response))
}
}
async fn describe_nfs_file_shares(
&self,
input: DescribeNFSFileSharesInput,
) -> Result<DescribeNFSFileSharesOutput, RusotoError<DescribeNFSFileSharesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeNFSFileShares",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeNFSFileSharesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeNFSFileSharesError::from_response(response))
}
}
async fn describe_smb_file_shares(
&self,
input: DescribeSMBFileSharesInput,
) -> Result<DescribeSMBFileSharesOutput, RusotoError<DescribeSMBFileSharesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeSMBFileShares",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeSMBFileSharesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeSMBFileSharesError::from_response(response))
}
}
async fn describe_smb_settings(
&self,
input: DescribeSMBSettingsInput,
) -> Result<DescribeSMBSettingsOutput, RusotoError<DescribeSMBSettingsError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeSMBSettings",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeSMBSettingsOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeSMBSettingsError::from_response(response))
}
}
async fn describe_snapshot_schedule(
&self,
input: DescribeSnapshotScheduleInput,
) -> Result<DescribeSnapshotScheduleOutput, RusotoError<DescribeSnapshotScheduleError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeSnapshotSchedule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeSnapshotScheduleOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeSnapshotScheduleError::from_response(response))
}
}
async fn describe_storedi_scsi_volumes(
&self,
input: DescribeStorediSCSIVolumesInput,
) -> Result<DescribeStorediSCSIVolumesOutput, RusotoError<DescribeStorediSCSIVolumesError>>
{
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeStorediSCSIVolumes",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeStorediSCSIVolumesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeStorediSCSIVolumesError::from_response(response))
}
}
async fn describe_tape_archives(
&self,
input: DescribeTapeArchivesInput,
) -> Result<DescribeTapeArchivesOutput, RusotoError<DescribeTapeArchivesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeTapeArchives",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeTapeArchivesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeTapeArchivesError::from_response(response))
}
}
async fn describe_tape_recovery_points(
&self,
input: DescribeTapeRecoveryPointsInput,
) -> Result<DescribeTapeRecoveryPointsOutput, RusotoError<DescribeTapeRecoveryPointsError>>
{
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeTapeRecoveryPoints",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeTapeRecoveryPointsOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeTapeRecoveryPointsError::from_response(response))
}
}
async fn describe_tapes(
&self,
input: DescribeTapesInput,
) -> Result<DescribeTapesOutput, RusotoError<DescribeTapesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DescribeTapes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeTapesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeTapesError::from_response(response))
}
}
async fn describe_upload_buffer(
&self,
input: DescribeUploadBufferInput,
) -> Result<DescribeUploadBufferOutput, RusotoError<DescribeUploadBufferError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeUploadBuffer",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeUploadBufferOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeUploadBufferError::from_response(response))
}
}
async fn describe_vtl_devices(
&self,
input: DescribeVTLDevicesInput,
) -> Result<DescribeVTLDevicesOutput, RusotoError<DescribeVTLDevicesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DescribeVTLDevices");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeVTLDevicesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeVTLDevicesError::from_response(response))
}
}
async fn describe_working_storage(
&self,
input: DescribeWorkingStorageInput,
) -> Result<DescribeWorkingStorageOutput, RusotoError<DescribeWorkingStorageError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.DescribeWorkingStorage",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeWorkingStorageOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DescribeWorkingStorageError::from_response(response))
}
}
async fn detach_volume(
&self,
input: DetachVolumeInput,
) -> Result<DetachVolumeOutput, RusotoError<DetachVolumeError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DetachVolume");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DetachVolumeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DetachVolumeError::from_response(response))
}
}
async fn disable_gateway(
&self,
input: DisableGatewayInput,
) -> Result<DisableGatewayOutput, RusotoError<DisableGatewayError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.DisableGateway");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DisableGatewayOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(DisableGatewayError::from_response(response))
}
}
async fn join_domain(
&self,
input: JoinDomainInput,
) -> Result<JoinDomainOutput, RusotoError<JoinDomainError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.JoinDomain");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<JoinDomainOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(JoinDomainError::from_response(response))
}
}
async fn list_automatic_tape_creation_policies(
&self,
input: ListAutomaticTapeCreationPoliciesInput,
) -> Result<
ListAutomaticTapeCreationPoliciesOutput,
RusotoError<ListAutomaticTapeCreationPoliciesError>,
> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.ListAutomaticTapeCreationPolicies",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAutomaticTapeCreationPoliciesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListAutomaticTapeCreationPoliciesError::from_response(
response,
))
}
}
async fn list_file_shares(
&self,
input: ListFileSharesInput,
) -> Result<ListFileSharesOutput, RusotoError<ListFileSharesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.ListFileShares");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListFileSharesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListFileSharesError::from_response(response))
}
}
async fn list_gateways(
&self,
input: ListGatewaysInput,
) -> Result<ListGatewaysOutput, RusotoError<ListGatewaysError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.ListGateways");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListGatewaysOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListGatewaysError::from_response(response))
}
}
async fn list_local_disks(
&self,
input: ListLocalDisksInput,
) -> Result<ListLocalDisksOutput, RusotoError<ListLocalDisksError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.ListLocalDisks");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLocalDisksOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListLocalDisksError::from_response(response))
}
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.ListTagsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
async fn list_tapes(
&self,
input: ListTapesInput,
) -> Result<ListTapesOutput, RusotoError<ListTapesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.ListTapes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTapesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListTapesError::from_response(response))
}
}
async fn list_volume_initiators(
&self,
input: ListVolumeInitiatorsInput,
) -> Result<ListVolumeInitiatorsOutput, RusotoError<ListVolumeInitiatorsError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.ListVolumeInitiators",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListVolumeInitiatorsOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListVolumeInitiatorsError::from_response(response))
}
}
async fn list_volume_recovery_points(
&self,
input: ListVolumeRecoveryPointsInput,
) -> Result<ListVolumeRecoveryPointsOutput, RusotoError<ListVolumeRecoveryPointsError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.ListVolumeRecoveryPoints",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListVolumeRecoveryPointsOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListVolumeRecoveryPointsError::from_response(response))
}
}
async fn list_volumes(
&self,
input: ListVolumesInput,
) -> Result<ListVolumesOutput, RusotoError<ListVolumesError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.ListVolumes");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListVolumesOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ListVolumesError::from_response(response))
}
}
async fn notify_when_uploaded(
&self,
input: NotifyWhenUploadedInput,
) -> Result<NotifyWhenUploadedOutput, RusotoError<NotifyWhenUploadedError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.NotifyWhenUploaded");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<NotifyWhenUploadedOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(NotifyWhenUploadedError::from_response(response))
}
}
async fn refresh_cache(
&self,
input: RefreshCacheInput,
) -> Result<RefreshCacheOutput, RusotoError<RefreshCacheError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.RefreshCache");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RefreshCacheOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(RefreshCacheError::from_response(response))
}
}
async fn remove_tags_from_resource(
&self,
input: RemoveTagsFromResourceInput,
) -> Result<RemoveTagsFromResourceOutput, RusotoError<RemoveTagsFromResourceError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.RemoveTagsFromResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RemoveTagsFromResourceOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(RemoveTagsFromResourceError::from_response(response))
}
}
async fn reset_cache(
&self,
input: ResetCacheInput,
) -> Result<ResetCacheOutput, RusotoError<ResetCacheError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.ResetCache");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ResetCacheOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ResetCacheError::from_response(response))
}
}
async fn retrieve_tape_archive(
&self,
input: RetrieveTapeArchiveInput,
) -> Result<RetrieveTapeArchiveOutput, RusotoError<RetrieveTapeArchiveError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.RetrieveTapeArchive",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RetrieveTapeArchiveOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(RetrieveTapeArchiveError::from_response(response))
}
}
async fn retrieve_tape_recovery_point(
&self,
input: RetrieveTapeRecoveryPointInput,
) -> Result<RetrieveTapeRecoveryPointOutput, RusotoError<RetrieveTapeRecoveryPointError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.RetrieveTapeRecoveryPoint",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<RetrieveTapeRecoveryPointOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(RetrieveTapeRecoveryPointError::from_response(response))
}
}
async fn set_local_console_password(
&self,
input: SetLocalConsolePasswordInput,
) -> Result<SetLocalConsolePasswordOutput, RusotoError<SetLocalConsolePasswordError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.SetLocalConsolePassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SetLocalConsolePasswordOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(SetLocalConsolePasswordError::from_response(response))
}
}
async fn set_smb_guest_password(
&self,
input: SetSMBGuestPasswordInput,
) -> Result<SetSMBGuestPasswordOutput, RusotoError<SetSMBGuestPasswordError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.SetSMBGuestPassword",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SetSMBGuestPasswordOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(SetSMBGuestPasswordError::from_response(response))
}
}
async fn shutdown_gateway(
&self,
input: ShutdownGatewayInput,
) -> Result<ShutdownGatewayOutput, RusotoError<ShutdownGatewayError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.ShutdownGateway");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ShutdownGatewayOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(ShutdownGatewayError::from_response(response))
}
}
async fn start_availability_monitor_test(
&self,
input: StartAvailabilityMonitorTestInput,
) -> Result<StartAvailabilityMonitorTestOutput, RusotoError<StartAvailabilityMonitorTestError>>
{
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.StartAvailabilityMonitorTest",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<StartAvailabilityMonitorTestOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StartAvailabilityMonitorTestError::from_response(response))
}
}
async fn start_gateway(
&self,
input: StartGatewayInput,
) -> Result<StartGatewayOutput, RusotoError<StartGatewayError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.StartGateway");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<StartGatewayOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(StartGatewayError::from_response(response))
}
}
async fn update_automatic_tape_creation_policy(
&self,
input: UpdateAutomaticTapeCreationPolicyInput,
) -> Result<
UpdateAutomaticTapeCreationPolicyOutput,
RusotoError<UpdateAutomaticTapeCreationPolicyError>,
> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateAutomaticTapeCreationPolicy",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateAutomaticTapeCreationPolicyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateAutomaticTapeCreationPolicyError::from_response(
response,
))
}
}
async fn update_bandwidth_rate_limit(
&self,
input: UpdateBandwidthRateLimitInput,
) -> Result<UpdateBandwidthRateLimitOutput, RusotoError<UpdateBandwidthRateLimitError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateBandwidthRateLimit",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateBandwidthRateLimitOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateBandwidthRateLimitError::from_response(response))
}
}
async fn update_chap_credentials(
&self,
input: UpdateChapCredentialsInput,
) -> Result<UpdateChapCredentialsOutput, RusotoError<UpdateChapCredentialsError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateChapCredentials",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateChapCredentialsOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateChapCredentialsError::from_response(response))
}
}
async fn update_gateway_information(
&self,
input: UpdateGatewayInformationInput,
) -> Result<UpdateGatewayInformationOutput, RusotoError<UpdateGatewayInformationError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateGatewayInformation",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateGatewayInformationOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateGatewayInformationError::from_response(response))
}
}
async fn update_gateway_software_now(
&self,
input: UpdateGatewaySoftwareNowInput,
) -> Result<UpdateGatewaySoftwareNowOutput, RusotoError<UpdateGatewaySoftwareNowError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateGatewaySoftwareNow",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateGatewaySoftwareNowOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateGatewaySoftwareNowError::from_response(response))
}
}
async fn update_maintenance_start_time(
&self,
input: UpdateMaintenanceStartTimeInput,
) -> Result<UpdateMaintenanceStartTimeOutput, RusotoError<UpdateMaintenanceStartTimeError>>
{
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateMaintenanceStartTime",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateMaintenanceStartTimeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateMaintenanceStartTimeError::from_response(response))
}
}
async fn update_nfs_file_share(
&self,
input: UpdateNFSFileShareInput,
) -> Result<UpdateNFSFileShareOutput, RusotoError<UpdateNFSFileShareError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.UpdateNFSFileShare");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateNFSFileShareOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateNFSFileShareError::from_response(response))
}
}
async fn update_smb_file_share(
&self,
input: UpdateSMBFileShareInput,
) -> Result<UpdateSMBFileShareOutput, RusotoError<UpdateSMBFileShareError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-target", "StorageGateway_20130630.UpdateSMBFileShare");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateSMBFileShareOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateSMBFileShareError::from_response(response))
}
}
async fn update_smb_security_strategy(
&self,
input: UpdateSMBSecurityStrategyInput,
) -> Result<UpdateSMBSecurityStrategyOutput, RusotoError<UpdateSMBSecurityStrategyError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateSMBSecurityStrategy",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateSMBSecurityStrategyOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateSMBSecurityStrategyError::from_response(response))
}
}
async fn update_snapshot_schedule(
&self,
input: UpdateSnapshotScheduleInput,
) -> Result<UpdateSnapshotScheduleOutput, RusotoError<UpdateSnapshotScheduleError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateSnapshotSchedule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateSnapshotScheduleOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateSnapshotScheduleError::from_response(response))
}
}
async fn update_vtl_device_type(
&self,
input: UpdateVTLDeviceTypeInput,
) -> Result<UpdateVTLDeviceTypeOutput, RusotoError<UpdateVTLDeviceTypeError>> {
let mut request = SignedRequest::new("POST", "storagegateway", &self.region, "/");
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header(
"x-amz-target",
"StorageGateway_20130630.UpdateVTLDeviceType",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateVTLDeviceTypeOutput, _>()
} else {
let try_response = response.buffer().await;
let response = try_response.map_err(RusotoError::HttpDispatch)?;
Err(UpdateVTLDeviceTypeError::from_response(response))
}
}
}