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::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BackupJob {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "BackupJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_job_id: Option<String>,
#[serde(rename = "BackupSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_size_in_bytes: Option<i64>,
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "BytesTransferred")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_transferred: Option<i64>,
#[serde(rename = "CompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date: Option<f64>,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<RecoveryPointCreator>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "ExpectedCompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expected_completion_date: Option<f64>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "PercentDone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub percent_done: Option<String>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "StartBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_by: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BackupPlan {
#[serde(rename = "BackupPlanName")]
pub backup_plan_name: String,
#[serde(rename = "Rules")]
pub rules: Vec<BackupRule>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BackupPlanInput {
#[serde(rename = "BackupPlanName")]
pub backup_plan_name: String,
#[serde(rename = "Rules")]
pub rules: Vec<BackupRuleInput>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BackupPlanTemplatesListMember {
#[serde(rename = "BackupPlanTemplateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_template_id: Option<String>,
#[serde(rename = "BackupPlanTemplateName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_template_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BackupPlansListMember {
#[serde(rename = "BackupPlanArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_arn: Option<String>,
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "BackupPlanName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_name: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "DeletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deletion_date: Option<f64>,
#[serde(rename = "LastExecutionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_execution_date: Option<f64>,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BackupRule {
#[serde(rename = "CompletionWindowMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_window_minutes: Option<i64>,
#[serde(rename = "CopyActions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_actions: Option<Vec<CopyAction>>,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
#[serde(rename = "RecoveryPointTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RuleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rule_id: Option<String>,
#[serde(rename = "RuleName")]
pub rule_name: String,
#[serde(rename = "ScheduleExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule_expression: Option<String>,
#[serde(rename = "StartWindowMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_window_minutes: Option<i64>,
#[serde(rename = "TargetBackupVaultName")]
pub target_backup_vault_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BackupRuleInput {
#[serde(rename = "CompletionWindowMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_window_minutes: Option<i64>,
#[serde(rename = "CopyActions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_actions: Option<Vec<CopyAction>>,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
#[serde(rename = "RecoveryPointTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RuleName")]
pub rule_name: String,
#[serde(rename = "ScheduleExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schedule_expression: Option<String>,
#[serde(rename = "StartWindowMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_window_minutes: Option<i64>,
#[serde(rename = "TargetBackupVaultName")]
pub target_backup_vault_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BackupSelection {
#[serde(rename = "IamRoleArn")]
pub iam_role_arn: String,
#[serde(rename = "ListOfTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_of_tags: Option<Vec<Condition>>,
#[serde(rename = "Resources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resources: Option<Vec<String>>,
#[serde(rename = "SelectionName")]
pub selection_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BackupSelectionsListMember {
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "SelectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selection_id: Option<String>,
#[serde(rename = "SelectionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selection_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BackupVaultListMember {
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "EncryptionKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_key_arn: Option<String>,
#[serde(rename = "NumberOfRecoveryPoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_recovery_points: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CalculatedLifecycle {
#[serde(rename = "DeleteAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_at: Option<f64>,
#[serde(rename = "MoveToColdStorageAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub move_to_cold_storage_at: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Condition {
#[serde(rename = "ConditionKey")]
pub condition_key: String,
#[serde(rename = "ConditionType")]
pub condition_type: String,
#[serde(rename = "ConditionValue")]
pub condition_value: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CopyAction {
#[serde(rename = "DestinationBackupVaultArn")]
pub destination_backup_vault_arn: String,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CopyJob {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "BackupSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_size_in_bytes: Option<i64>,
#[serde(rename = "CompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date: Option<f64>,
#[serde(rename = "CopyJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_job_id: Option<String>,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<RecoveryPointCreator>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "DestinationBackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_backup_vault_arn: Option<String>,
#[serde(rename = "DestinationRecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_recovery_point_arn: Option<String>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "SourceBackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_backup_vault_arn: Option<String>,
#[serde(rename = "SourceRecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_recovery_point_arn: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateBackupPlanInput {
#[serde(rename = "BackupPlan")]
pub backup_plan: BackupPlanInput,
#[serde(rename = "BackupPlanTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateBackupPlanOutput {
#[serde(rename = "BackupPlanArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_arn: Option<String>,
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateBackupSelectionInput {
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
#[serde(rename = "BackupSelection")]
pub backup_selection: BackupSelection,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateBackupSelectionOutput {
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "SelectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selection_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateBackupVaultInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "BackupVaultTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "EncryptionKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_key_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateBackupVaultOutput {
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBackupPlanInput {
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteBackupPlanOutput {
#[serde(rename = "BackupPlanArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_arn: Option<String>,
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "DeletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deletion_date: Option<f64>,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBackupSelectionInput {
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
#[serde(rename = "SelectionId")]
pub selection_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBackupVaultAccessPolicyInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBackupVaultInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBackupVaultNotificationsInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRecoveryPointInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "RecoveryPointArn")]
pub recovery_point_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeBackupJobInput {
#[serde(rename = "BackupJobId")]
pub backup_job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeBackupJobOutput {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "BackupJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_job_id: Option<String>,
#[serde(rename = "BackupSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_size_in_bytes: Option<i64>,
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "BytesTransferred")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bytes_transferred: Option<i64>,
#[serde(rename = "CompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date: Option<f64>,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<RecoveryPointCreator>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "ExpectedCompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expected_completion_date: Option<f64>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "PercentDone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub percent_done: Option<String>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "StartBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_by: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeBackupVaultInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeBackupVaultOutput {
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "EncryptionKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_key_arn: Option<String>,
#[serde(rename = "NumberOfRecoveryPoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_recovery_points: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeCopyJobInput {
#[serde(rename = "CopyJobId")]
pub copy_job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCopyJobOutput {
#[serde(rename = "CopyJob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_job: Option<CopyJob>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProtectedResourceInput {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProtectedResourceOutput {
#[serde(rename = "LastBackupTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_backup_time: Option<f64>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRecoveryPointInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "RecoveryPointArn")]
pub recovery_point_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRecoveryPointOutput {
#[serde(rename = "BackupSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_size_in_bytes: Option<i64>,
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "CalculatedLifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub calculated_lifecycle: Option<CalculatedLifecycle>,
#[serde(rename = "CompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date: Option<f64>,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<RecoveryPointCreator>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "EncryptionKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_key_arn: Option<String>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "IsEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_encrypted: Option<bool>,
#[serde(rename = "LastRestoreTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_restore_time: Option<f64>,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StorageClass")]
#[serde(skip_serializing_if = "Option::is_none")]
pub storage_class: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRegionSettingsInput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRegionSettingsOutput {
#[serde(rename = "ResourceTypeOptInPreference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type_opt_in_preference: Option<::std::collections::HashMap<String, bool>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRestoreJobInput {
#[serde(rename = "RestoreJobId")]
pub restore_job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRestoreJobOutput {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "BackupSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_size_in_bytes: Option<i64>,
#[serde(rename = "CompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date: Option<f64>,
#[serde(rename = "CreatedResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_resource_arn: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "ExpectedCompletionTimeMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expected_completion_time_minutes: Option<i64>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "PercentDone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub percent_done: Option<String>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "RestoreJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_job_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExportBackupPlanTemplateInput {
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExportBackupPlanTemplateOutput {
#[serde(rename = "BackupPlanTemplateJson")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_template_json: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBackupPlanFromJSONInput {
#[serde(rename = "BackupPlanTemplateJson")]
pub backup_plan_template_json: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBackupPlanFromJSONOutput {
#[serde(rename = "BackupPlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan: Option<BackupPlan>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBackupPlanFromTemplateInput {
#[serde(rename = "BackupPlanTemplateId")]
pub backup_plan_template_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBackupPlanFromTemplateOutput {
#[serde(rename = "BackupPlanDocument")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_document: Option<BackupPlan>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBackupPlanInput {
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBackupPlanOutput {
#[serde(rename = "BackupPlan")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan: Option<BackupPlan>,
#[serde(rename = "BackupPlanArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_arn: Option<String>,
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "DeletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deletion_date: Option<f64>,
#[serde(rename = "LastExecutionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_execution_date: Option<f64>,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBackupSelectionInput {
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
#[serde(rename = "SelectionId")]
pub selection_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBackupSelectionOutput {
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "BackupSelection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_selection: Option<BackupSelection>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "CreatorRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creator_request_id: Option<String>,
#[serde(rename = "SelectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selection_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBackupVaultAccessPolicyInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBackupVaultAccessPolicyOutput {
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "Policy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBackupVaultNotificationsInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBackupVaultNotificationsOutput {
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultEvents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_events: Option<Vec<String>>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "SNSTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRecoveryPointRestoreMetadataInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "RecoveryPointArn")]
pub recovery_point_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRecoveryPointRestoreMetadataOutput {
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
#[serde(rename = "RestoreMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_metadata: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSupportedResourceTypesOutput {
#[serde(rename = "ResourceTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_types: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Lifecycle {
#[serde(rename = "DeleteAfterDays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_after_days: Option<i64>,
#[serde(rename = "MoveToColdStorageAfterDays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub move_to_cold_storage_after_days: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBackupJobsInput {
#[serde(rename = "ByAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_account_id: Option<String>,
#[serde(rename = "ByBackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_backup_vault_name: Option<String>,
#[serde(rename = "ByCreatedAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_created_after: Option<f64>,
#[serde(rename = "ByCreatedBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_created_before: Option<f64>,
#[serde(rename = "ByResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_resource_arn: Option<String>,
#[serde(rename = "ByResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_resource_type: Option<String>,
#[serde(rename = "ByState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_state: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBackupJobsOutput {
#[serde(rename = "BackupJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_jobs: Option<Vec<BackupJob>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBackupPlanTemplatesInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBackupPlanTemplatesOutput {
#[serde(rename = "BackupPlanTemplatesList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_templates_list: Option<Vec<BackupPlanTemplatesListMember>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBackupPlanVersionsInput {
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBackupPlanVersionsOutput {
#[serde(rename = "BackupPlanVersionsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_versions_list: Option<Vec<BackupPlansListMember>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBackupPlansInput {
#[serde(rename = "IncludeDeleted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_deleted: Option<bool>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBackupPlansOutput {
#[serde(rename = "BackupPlansList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plans_list: Option<Vec<BackupPlansListMember>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBackupSelectionsInput {
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBackupSelectionsOutput {
#[serde(rename = "BackupSelectionsList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_selections_list: Option<Vec<BackupSelectionsListMember>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBackupVaultsInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBackupVaultsOutput {
#[serde(rename = "BackupVaultList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_list: Option<Vec<BackupVaultListMember>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCopyJobsInput {
#[serde(rename = "ByAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_account_id: Option<String>,
#[serde(rename = "ByCreatedAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_created_after: Option<f64>,
#[serde(rename = "ByCreatedBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_created_before: Option<f64>,
#[serde(rename = "ByDestinationVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_destination_vault_arn: Option<String>,
#[serde(rename = "ByResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_resource_arn: Option<String>,
#[serde(rename = "ByResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_resource_type: Option<String>,
#[serde(rename = "ByState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_state: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCopyJobsOutput {
#[serde(rename = "CopyJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_jobs: Option<Vec<CopyJob>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProtectedResourcesInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProtectedResourcesOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Results")]
#[serde(skip_serializing_if = "Option::is_none")]
pub results: Option<Vec<ProtectedResource>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRecoveryPointsByBackupVaultInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "ByBackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_backup_plan_id: Option<String>,
#[serde(rename = "ByCreatedAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_created_after: Option<f64>,
#[serde(rename = "ByCreatedBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_created_before: Option<f64>,
#[serde(rename = "ByResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_resource_arn: Option<String>,
#[serde(rename = "ByResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_resource_type: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRecoveryPointsByBackupVaultOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RecoveryPoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_points: Option<Vec<RecoveryPointByBackupVault>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRecoveryPointsByResourceInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRecoveryPointsByResourceOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RecoveryPoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_points: Option<Vec<RecoveryPointByResource>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRestoreJobsInput {
#[serde(rename = "ByAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_account_id: Option<String>,
#[serde(rename = "ByCreatedAfter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_created_after: Option<f64>,
#[serde(rename = "ByCreatedBefore")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_created_before: Option<f64>,
#[serde(rename = "ByStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub by_status: Option<String>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRestoreJobsOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RestoreJobs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_jobs: Option<Vec<RestoreJobsListMember>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProtectedResource {
#[serde(rename = "LastBackupTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_backup_time: Option<f64>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutBackupVaultAccessPolicyInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "Policy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutBackupVaultNotificationsInput {
#[serde(rename = "BackupVaultEvents")]
pub backup_vault_events: Vec<String>,
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "SNSTopicArn")]
pub sns_topic_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecoveryPointByBackupVault {
#[serde(rename = "BackupSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_size_in_bytes: Option<i64>,
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "CalculatedLifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub calculated_lifecycle: Option<CalculatedLifecycle>,
#[serde(rename = "CompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date: Option<f64>,
#[serde(rename = "CreatedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_by: Option<RecoveryPointCreator>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "EncryptionKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_key_arn: Option<String>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "IsEncrypted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_encrypted: Option<bool>,
#[serde(rename = "LastRestoreTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_restore_time: Option<f64>,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecoveryPointByResource {
#[serde(rename = "BackupSizeBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_size_bytes: Option<i64>,
#[serde(rename = "BackupVaultName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_name: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "EncryptionKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub encryption_key_arn: Option<String>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecoveryPointCreator {
#[serde(rename = "BackupPlanArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_arn: Option<String>,
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "BackupPlanVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_version: Option<String>,
#[serde(rename = "BackupRuleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_rule_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RestoreJobsListMember {
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "BackupSizeInBytes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_size_in_bytes: Option<i64>,
#[serde(rename = "CompletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub completion_date: Option<f64>,
#[serde(rename = "CreatedResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_resource_arn: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "ExpectedCompletionTimeMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expected_completion_time_minutes: Option<i64>,
#[serde(rename = "IamRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_role_arn: Option<String>,
#[serde(rename = "PercentDone")]
#[serde(skip_serializing_if = "Option::is_none")]
pub percent_done: Option<String>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "RestoreJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_job_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartBackupJobInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "CompleteWindowMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub complete_window_minutes: Option<i64>,
#[serde(rename = "IamRoleArn")]
pub iam_role_arn: String,
#[serde(rename = "IdempotencyToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idempotency_token: Option<String>,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
#[serde(rename = "RecoveryPointTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "StartWindowMinutes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_window_minutes: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartBackupJobOutput {
#[serde(rename = "BackupJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_job_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartCopyJobInput {
#[serde(rename = "DestinationBackupVaultArn")]
pub destination_backup_vault_arn: String,
#[serde(rename = "IamRoleArn")]
pub iam_role_arn: String,
#[serde(rename = "IdempotencyToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idempotency_token: Option<String>,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
#[serde(rename = "RecoveryPointArn")]
pub recovery_point_arn: String,
#[serde(rename = "SourceBackupVaultName")]
pub source_backup_vault_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartCopyJobOutput {
#[serde(rename = "CopyJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_job_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartRestoreJobInput {
#[serde(rename = "IamRoleArn")]
pub iam_role_arn: String,
#[serde(rename = "IdempotencyToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idempotency_token: Option<String>,
#[serde(rename = "Metadata")]
pub metadata: ::std::collections::HashMap<String, String>,
#[serde(rename = "RecoveryPointArn")]
pub recovery_point_arn: String,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartRestoreJobOutput {
#[serde(rename = "RestoreJobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub restore_job_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopBackupJobInput {
#[serde(rename = "BackupJobId")]
pub backup_job_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceInput {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceInput {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeyList")]
pub tag_key_list: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateBackupPlanInput {
#[serde(rename = "BackupPlan")]
pub backup_plan: BackupPlanInput,
#[serde(rename = "BackupPlanId")]
pub backup_plan_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateBackupPlanOutput {
#[serde(rename = "BackupPlanArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_arn: Option<String>,
#[serde(rename = "BackupPlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_plan_id: Option<String>,
#[serde(rename = "CreationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "VersionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRecoveryPointLifecycleInput {
#[serde(rename = "BackupVaultName")]
pub backup_vault_name: String,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
#[serde(rename = "RecoveryPointArn")]
pub recovery_point_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRecoveryPointLifecycleOutput {
#[serde(rename = "BackupVaultArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backup_vault_arn: Option<String>,
#[serde(rename = "CalculatedLifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub calculated_lifecycle: Option<CalculatedLifecycle>,
#[serde(rename = "Lifecycle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lifecycle: Option<Lifecycle>,
#[serde(rename = "RecoveryPointArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub recovery_point_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRegionSettingsInput {
#[serde(rename = "ResourceTypeOptInPreference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type_opt_in_preference: Option<::std::collections::HashMap<String, bool>>,
}
#[derive(Debug, PartialEq)]
pub enum CreateBackupPlanError {
AlreadyExists(String),
InvalidParameterValue(String),
LimitExceeded(String),
MissingParameterValue(String),
ServiceUnavailable(String),
}
impl CreateBackupPlanError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateBackupPlanError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(CreateBackupPlanError::AlreadyExists(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateBackupPlanError::InvalidParameterValue(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateBackupPlanError::LimitExceeded(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(CreateBackupPlanError::MissingParameterValue(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateBackupPlanError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateBackupPlanError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateBackupPlanError::AlreadyExists(ref cause) => write!(f, "{}", cause),
CreateBackupPlanError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateBackupPlanError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateBackupPlanError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
CreateBackupPlanError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateBackupPlanError {}
#[derive(Debug, PartialEq)]
pub enum CreateBackupSelectionError {
AlreadyExists(String),
InvalidParameterValue(String),
LimitExceeded(String),
MissingParameterValue(String),
ServiceUnavailable(String),
}
impl CreateBackupSelectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateBackupSelectionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(CreateBackupSelectionError::AlreadyExists(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateBackupSelectionError::InvalidParameterValue(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateBackupSelectionError::LimitExceeded(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(CreateBackupSelectionError::MissingParameterValue(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateBackupSelectionError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateBackupSelectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateBackupSelectionError::AlreadyExists(ref cause) => write!(f, "{}", cause),
CreateBackupSelectionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateBackupSelectionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateBackupSelectionError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
CreateBackupSelectionError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateBackupSelectionError {}
#[derive(Debug, PartialEq)]
pub enum CreateBackupVaultError {
AlreadyExists(String),
InvalidParameterValue(String),
LimitExceeded(String),
MissingParameterValue(String),
ServiceUnavailable(String),
}
impl CreateBackupVaultError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateBackupVaultError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AlreadyExistsException" => {
return RusotoError::Service(CreateBackupVaultError::AlreadyExists(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateBackupVaultError::InvalidParameterValue(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateBackupVaultError::LimitExceeded(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(CreateBackupVaultError::MissingParameterValue(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(CreateBackupVaultError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateBackupVaultError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateBackupVaultError::AlreadyExists(ref cause) => write!(f, "{}", cause),
CreateBackupVaultError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateBackupVaultError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateBackupVaultError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
CreateBackupVaultError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateBackupVaultError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBackupPlanError {
InvalidParameterValue(String),
InvalidRequest(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DeleteBackupPlanError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteBackupPlanError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteBackupPlanError::InvalidParameterValue(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteBackupPlanError::InvalidRequest(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(DeleteBackupPlanError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteBackupPlanError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteBackupPlanError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBackupPlanError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBackupPlanError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteBackupPlanError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteBackupPlanError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DeleteBackupPlanError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteBackupPlanError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteBackupPlanError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBackupSelectionError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DeleteBackupSelectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteBackupSelectionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteBackupSelectionError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(DeleteBackupSelectionError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteBackupSelectionError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteBackupSelectionError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBackupSelectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBackupSelectionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteBackupSelectionError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DeleteBackupSelectionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteBackupSelectionError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteBackupSelectionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBackupVaultError {
InvalidParameterValue(String),
InvalidRequest(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DeleteBackupVaultError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteBackupVaultError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteBackupVaultError::InvalidParameterValue(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteBackupVaultError::InvalidRequest(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(DeleteBackupVaultError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteBackupVaultError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteBackupVaultError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBackupVaultError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBackupVaultError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteBackupVaultError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteBackupVaultError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DeleteBackupVaultError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteBackupVaultError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteBackupVaultError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBackupVaultAccessPolicyError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DeleteBackupVaultAccessPolicyError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteBackupVaultAccessPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteBackupVaultAccessPolicyError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
DeleteBackupVaultAccessPolicyError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteBackupVaultAccessPolicyError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DeleteBackupVaultAccessPolicyError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBackupVaultAccessPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBackupVaultAccessPolicyError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteBackupVaultAccessPolicyError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteBackupVaultAccessPolicyError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteBackupVaultAccessPolicyError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteBackupVaultAccessPolicyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBackupVaultNotificationsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DeleteBackupVaultNotificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteBackupVaultNotificationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteBackupVaultNotificationsError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
DeleteBackupVaultNotificationsError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteBackupVaultNotificationsError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DeleteBackupVaultNotificationsError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBackupVaultNotificationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBackupVaultNotificationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteBackupVaultNotificationsError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteBackupVaultNotificationsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteBackupVaultNotificationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteBackupVaultNotificationsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRecoveryPointError {
InvalidParameterValue(String),
InvalidRequest(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DeleteRecoveryPointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRecoveryPointError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteRecoveryPointError::InvalidParameterValue(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(DeleteRecoveryPointError::InvalidRequest(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(DeleteRecoveryPointError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteRecoveryPointError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DeleteRecoveryPointError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRecoveryPointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRecoveryPointError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteRecoveryPointError::InvalidRequest(ref cause) => write!(f, "{}", cause),
DeleteRecoveryPointError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DeleteRecoveryPointError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteRecoveryPointError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRecoveryPointError {}
#[derive(Debug, PartialEq)]
pub enum DescribeBackupJobError {
DependencyFailure(String),
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DescribeBackupJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeBackupJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyFailureException" => {
return RusotoError::Service(DescribeBackupJobError::DependencyFailure(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeBackupJobError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(DescribeBackupJobError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeBackupJobError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeBackupJobError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeBackupJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeBackupJobError::DependencyFailure(ref cause) => write!(f, "{}", cause),
DescribeBackupJobError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeBackupJobError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DescribeBackupJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeBackupJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeBackupJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeBackupVaultError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DescribeBackupVaultError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeBackupVaultError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeBackupVaultError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(DescribeBackupVaultError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeBackupVaultError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeBackupVaultError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeBackupVaultError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeBackupVaultError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeBackupVaultError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DescribeBackupVaultError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeBackupVaultError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeBackupVaultError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCopyJobError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DescribeCopyJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCopyJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeCopyJobError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(DescribeCopyJobError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeCopyJobError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeCopyJobError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCopyJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCopyJobError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeCopyJobError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DescribeCopyJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeCopyJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeCopyJobError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProtectedResourceError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DescribeProtectedResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeProtectedResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DescribeProtectedResourceError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
DescribeProtectedResourceError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeProtectedResourceError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
DescribeProtectedResourceError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProtectedResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProtectedResourceError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeProtectedResourceError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DescribeProtectedResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeProtectedResourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeProtectedResourceError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRecoveryPointError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DescribeRecoveryPointError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRecoveryPointError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeRecoveryPointError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(DescribeRecoveryPointError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeRecoveryPointError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeRecoveryPointError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRecoveryPointError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRecoveryPointError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeRecoveryPointError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DescribeRecoveryPointError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeRecoveryPointError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRecoveryPointError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRegionSettingsError {
ServiceUnavailable(String),
}
impl DescribeRegionSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRegionSettingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeRegionSettingsError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRegionSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRegionSettingsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRegionSettingsError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRestoreJobError {
DependencyFailure(String),
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl DescribeRestoreJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRestoreJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"DependencyFailureException" => {
return RusotoError::Service(DescribeRestoreJobError::DependencyFailure(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DescribeRestoreJobError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(DescribeRestoreJobError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeRestoreJobError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(DescribeRestoreJobError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRestoreJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRestoreJobError::DependencyFailure(ref cause) => write!(f, "{}", cause),
DescribeRestoreJobError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DescribeRestoreJobError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
DescribeRestoreJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeRestoreJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRestoreJobError {}
#[derive(Debug, PartialEq)]
pub enum ExportBackupPlanTemplateError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ExportBackupPlanTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ExportBackupPlanTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ExportBackupPlanTemplateError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
ExportBackupPlanTemplateError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ExportBackupPlanTemplateError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ExportBackupPlanTemplateError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExportBackupPlanTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExportBackupPlanTemplateError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ExportBackupPlanTemplateError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ExportBackupPlanTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ExportBackupPlanTemplateError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ExportBackupPlanTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetBackupPlanError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl GetBackupPlanError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBackupPlanError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetBackupPlanError::InvalidParameterValue(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(GetBackupPlanError::MissingParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetBackupPlanError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetBackupPlanError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBackupPlanError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBackupPlanError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetBackupPlanError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
GetBackupPlanError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetBackupPlanError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBackupPlanError {}
#[derive(Debug, PartialEq)]
pub enum GetBackupPlanFromJSONError {
InvalidParameterValue(String),
InvalidRequest(String),
LimitExceeded(String),
MissingParameterValue(String),
ServiceUnavailable(String),
}
impl GetBackupPlanFromJSONError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBackupPlanFromJSONError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetBackupPlanFromJSONError::InvalidParameterValue(
err.msg,
))
}
"InvalidRequestException" => {
return RusotoError::Service(GetBackupPlanFromJSONError::InvalidRequest(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(GetBackupPlanFromJSONError::LimitExceeded(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(GetBackupPlanFromJSONError::MissingParameterValue(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetBackupPlanFromJSONError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBackupPlanFromJSONError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBackupPlanFromJSONError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetBackupPlanFromJSONError::InvalidRequest(ref cause) => write!(f, "{}", cause),
GetBackupPlanFromJSONError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetBackupPlanFromJSONError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
GetBackupPlanFromJSONError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBackupPlanFromJSONError {}
#[derive(Debug, PartialEq)]
pub enum GetBackupPlanFromTemplateError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl GetBackupPlanFromTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBackupPlanFromTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetBackupPlanFromTemplateError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
GetBackupPlanFromTemplateError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetBackupPlanFromTemplateError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetBackupPlanFromTemplateError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBackupPlanFromTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBackupPlanFromTemplateError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetBackupPlanFromTemplateError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetBackupPlanFromTemplateError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetBackupPlanFromTemplateError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBackupPlanFromTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetBackupSelectionError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl GetBackupSelectionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBackupSelectionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetBackupSelectionError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(GetBackupSelectionError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetBackupSelectionError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(GetBackupSelectionError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBackupSelectionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBackupSelectionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetBackupSelectionError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
GetBackupSelectionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetBackupSelectionError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBackupSelectionError {}
#[derive(Debug, PartialEq)]
pub enum GetBackupVaultAccessPolicyError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl GetBackupVaultAccessPolicyError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetBackupVaultAccessPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetBackupVaultAccessPolicyError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
GetBackupVaultAccessPolicyError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetBackupVaultAccessPolicyError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetBackupVaultAccessPolicyError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBackupVaultAccessPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBackupVaultAccessPolicyError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetBackupVaultAccessPolicyError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetBackupVaultAccessPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetBackupVaultAccessPolicyError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetBackupVaultAccessPolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetBackupVaultNotificationsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl GetBackupVaultNotificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetBackupVaultNotificationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetBackupVaultNotificationsError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
GetBackupVaultNotificationsError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetBackupVaultNotificationsError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetBackupVaultNotificationsError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBackupVaultNotificationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBackupVaultNotificationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetBackupVaultNotificationsError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetBackupVaultNotificationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetBackupVaultNotificationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetBackupVaultNotificationsError {}
#[derive(Debug, PartialEq)]
pub enum GetRecoveryPointRestoreMetadataError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl GetRecoveryPointRestoreMetadataError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetRecoveryPointRestoreMetadataError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetRecoveryPointRestoreMetadataError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
GetRecoveryPointRestoreMetadataError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetRecoveryPointRestoreMetadataError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
GetRecoveryPointRestoreMetadataError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRecoveryPointRestoreMetadataError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRecoveryPointRestoreMetadataError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetRecoveryPointRestoreMetadataError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetRecoveryPointRestoreMetadataError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetRecoveryPointRestoreMetadataError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetRecoveryPointRestoreMetadataError {}
#[derive(Debug, PartialEq)]
pub enum GetSupportedResourceTypesError {
ServiceUnavailable(String),
}
impl GetSupportedResourceTypesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSupportedResourceTypesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ServiceUnavailableException" => {
return RusotoError::Service(
GetSupportedResourceTypesError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSupportedResourceTypesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSupportedResourceTypesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSupportedResourceTypesError {}
#[derive(Debug, PartialEq)]
pub enum ListBackupJobsError {
InvalidParameterValue(String),
ServiceUnavailable(String),
}
impl ListBackupJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBackupJobsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListBackupJobsError::InvalidParameterValue(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListBackupJobsError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBackupJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBackupJobsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupJobsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBackupJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListBackupPlanTemplatesError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListBackupPlanTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBackupPlanTemplatesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListBackupPlanTemplatesError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
ListBackupPlanTemplatesError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListBackupPlanTemplatesError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListBackupPlanTemplatesError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBackupPlanTemplatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBackupPlanTemplatesError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListBackupPlanTemplatesError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListBackupPlanTemplatesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListBackupPlanTemplatesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBackupPlanTemplatesError {}
#[derive(Debug, PartialEq)]
pub enum ListBackupPlanVersionsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListBackupPlanVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBackupPlanVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListBackupPlanVersionsError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
ListBackupPlanVersionsError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListBackupPlanVersionsError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListBackupPlanVersionsError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBackupPlanVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBackupPlanVersionsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupPlanVersionsError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupPlanVersionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListBackupPlanVersionsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBackupPlanVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListBackupPlansError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListBackupPlansError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBackupPlansError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListBackupPlansError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(ListBackupPlansError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListBackupPlansError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListBackupPlansError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBackupPlansError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBackupPlansError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupPlansError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupPlansError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListBackupPlansError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBackupPlansError {}
#[derive(Debug, PartialEq)]
pub enum ListBackupSelectionsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListBackupSelectionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBackupSelectionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListBackupSelectionsError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(ListBackupSelectionsError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListBackupSelectionsError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListBackupSelectionsError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBackupSelectionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBackupSelectionsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupSelectionsError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupSelectionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListBackupSelectionsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBackupSelectionsError {}
#[derive(Debug, PartialEq)]
pub enum ListBackupVaultsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListBackupVaultsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBackupVaultsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListBackupVaultsError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(ListBackupVaultsError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListBackupVaultsError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListBackupVaultsError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBackupVaultsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBackupVaultsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupVaultsError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
ListBackupVaultsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListBackupVaultsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBackupVaultsError {}
#[derive(Debug, PartialEq)]
pub enum ListCopyJobsError {
InvalidParameterValue(String),
ServiceUnavailable(String),
}
impl ListCopyJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCopyJobsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListCopyJobsError::InvalidParameterValue(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListCopyJobsError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCopyJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCopyJobsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListCopyJobsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListCopyJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListProtectedResourcesError {
InvalidParameterValue(String),
ServiceUnavailable(String),
}
impl ListProtectedResourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProtectedResourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListProtectedResourcesError::InvalidParameterValue(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListProtectedResourcesError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProtectedResourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProtectedResourcesError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListProtectedResourcesError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProtectedResourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListRecoveryPointsByBackupVaultError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListRecoveryPointsByBackupVaultError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListRecoveryPointsByBackupVaultError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListRecoveryPointsByBackupVaultError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
ListRecoveryPointsByBackupVaultError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListRecoveryPointsByBackupVaultError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListRecoveryPointsByBackupVaultError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRecoveryPointsByBackupVaultError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRecoveryPointsByBackupVaultError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListRecoveryPointsByBackupVaultError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListRecoveryPointsByBackupVaultError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListRecoveryPointsByBackupVaultError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListRecoveryPointsByBackupVaultError {}
#[derive(Debug, PartialEq)]
pub enum ListRecoveryPointsByResourceError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListRecoveryPointsByResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListRecoveryPointsByResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListRecoveryPointsByResourceError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
ListRecoveryPointsByResourceError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListRecoveryPointsByResourceError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
ListRecoveryPointsByResourceError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRecoveryPointsByResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRecoveryPointsByResourceError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListRecoveryPointsByResourceError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListRecoveryPointsByResourceError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListRecoveryPointsByResourceError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListRecoveryPointsByResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListRestoreJobsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListRestoreJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRestoreJobsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListRestoreJobsError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(ListRestoreJobsError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListRestoreJobsError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListRestoreJobsError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRestoreJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRestoreJobsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListRestoreJobsError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
ListRestoreJobsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListRestoreJobsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRestoreJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl ListTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListTagsError::InvalidParameterValue(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(ListTagsError::MissingParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(ListTagsError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListTagsError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
ListTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsError {}
#[derive(Debug, PartialEq)]
pub enum PutBackupVaultAccessPolicyError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl PutBackupVaultAccessPolicyError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutBackupVaultAccessPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutBackupVaultAccessPolicyError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
PutBackupVaultAccessPolicyError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(PutBackupVaultAccessPolicyError::ResourceNotFound(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(
PutBackupVaultAccessPolicyError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutBackupVaultAccessPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutBackupVaultAccessPolicyError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutBackupVaultAccessPolicyError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutBackupVaultAccessPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutBackupVaultAccessPolicyError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutBackupVaultAccessPolicyError {}
#[derive(Debug, PartialEq)]
pub enum PutBackupVaultNotificationsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl PutBackupVaultNotificationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutBackupVaultNotificationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutBackupVaultNotificationsError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
PutBackupVaultNotificationsError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
PutBackupVaultNotificationsError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
PutBackupVaultNotificationsError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutBackupVaultNotificationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutBackupVaultNotificationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutBackupVaultNotificationsError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutBackupVaultNotificationsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutBackupVaultNotificationsError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutBackupVaultNotificationsError {}
#[derive(Debug, PartialEq)]
pub enum StartBackupJobError {
InvalidParameterValue(String),
LimitExceeded(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl StartBackupJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartBackupJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(StartBackupJobError::InvalidParameterValue(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(StartBackupJobError::LimitExceeded(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(StartBackupJobError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartBackupJobError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(StartBackupJobError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartBackupJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartBackupJobError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StartBackupJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StartBackupJobError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
StartBackupJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartBackupJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartBackupJobError {}
#[derive(Debug, PartialEq)]
pub enum StartCopyJobError {
InvalidParameterValue(String),
LimitExceeded(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl StartCopyJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartCopyJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(StartCopyJobError::InvalidParameterValue(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(StartCopyJobError::LimitExceeded(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(StartCopyJobError::MissingParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartCopyJobError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(StartCopyJobError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartCopyJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartCopyJobError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StartCopyJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StartCopyJobError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
StartCopyJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartCopyJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartCopyJobError {}
#[derive(Debug, PartialEq)]
pub enum StartRestoreJobError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl StartRestoreJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartRestoreJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(StartRestoreJobError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(StartRestoreJobError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StartRestoreJobError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(StartRestoreJobError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartRestoreJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartRestoreJobError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StartRestoreJobError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
StartRestoreJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StartRestoreJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartRestoreJobError {}
#[derive(Debug, PartialEq)]
pub enum StopBackupJobError {
InvalidParameterValue(String),
InvalidRequest(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl StopBackupJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopBackupJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(StopBackupJobError::InvalidParameterValue(err.msg))
}
"InvalidRequestException" => {
return RusotoError::Service(StopBackupJobError::InvalidRequest(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(StopBackupJobError::MissingParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(StopBackupJobError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(StopBackupJobError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopBackupJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopBackupJobError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
StopBackupJobError::InvalidRequest(ref cause) => write!(f, "{}", cause),
StopBackupJobError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
StopBackupJobError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
StopBackupJobError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopBackupJobError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InvalidParameterValue(String),
LimitExceeded(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(TagResourceError::InvalidParameterValue(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(TagResourceError::LimitExceeded(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(TagResourceError::MissingParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(TagResourceError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
TagResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
TagResourceError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(UntagResourceError::InvalidParameterValue(err.msg))
}
"MissingParameterValueException" => {
return RusotoError::Service(UntagResourceError::MissingParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UntagResourceError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UntagResourceError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateBackupPlanError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl UpdateBackupPlanError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateBackupPlanError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(UpdateBackupPlanError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(UpdateBackupPlanError::MissingParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateBackupPlanError::ResourceNotFound(err.msg))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateBackupPlanError::ServiceUnavailable(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateBackupPlanError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateBackupPlanError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UpdateBackupPlanError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
UpdateBackupPlanError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateBackupPlanError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateBackupPlanError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRecoveryPointLifecycleError {
InvalidParameterValue(String),
MissingParameterValue(String),
ResourceNotFound(String),
ServiceUnavailable(String),
}
impl UpdateRecoveryPointLifecycleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateRecoveryPointLifecycleError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
UpdateRecoveryPointLifecycleError::InvalidParameterValue(err.msg),
)
}
"MissingParameterValueException" => {
return RusotoError::Service(
UpdateRecoveryPointLifecycleError::MissingParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateRecoveryPointLifecycleError::ResourceNotFound(err.msg),
)
}
"ServiceUnavailableException" => {
return RusotoError::Service(
UpdateRecoveryPointLifecycleError::ServiceUnavailable(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRecoveryPointLifecycleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRecoveryPointLifecycleError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
UpdateRecoveryPointLifecycleError::MissingParameterValue(ref cause) => {
write!(f, "{}", cause)
}
UpdateRecoveryPointLifecycleError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateRecoveryPointLifecycleError::ServiceUnavailable(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateRecoveryPointLifecycleError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRegionSettingsError {
InvalidParameterValue(String),
MissingParameterValue(String),
ServiceUnavailable(String),
}
impl UpdateRegionSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRegionSettingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(UpdateRegionSettingsError::InvalidParameterValue(
err.msg,
))
}
"MissingParameterValueException" => {
return RusotoError::Service(UpdateRegionSettingsError::MissingParameterValue(
err.msg,
))
}
"ServiceUnavailableException" => {
return RusotoError::Service(UpdateRegionSettingsError::ServiceUnavailable(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRegionSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRegionSettingsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UpdateRegionSettingsError::MissingParameterValue(ref cause) => write!(f, "{}", cause),
UpdateRegionSettingsError::ServiceUnavailable(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRegionSettingsError {}
#[async_trait]
pub trait Backup {
async fn create_backup_plan(
&self,
input: CreateBackupPlanInput,
) -> Result<CreateBackupPlanOutput, RusotoError<CreateBackupPlanError>>;
async fn create_backup_selection(
&self,
input: CreateBackupSelectionInput,
) -> Result<CreateBackupSelectionOutput, RusotoError<CreateBackupSelectionError>>;
async fn create_backup_vault(
&self,
input: CreateBackupVaultInput,
) -> Result<CreateBackupVaultOutput, RusotoError<CreateBackupVaultError>>;
async fn delete_backup_plan(
&self,
input: DeleteBackupPlanInput,
) -> Result<DeleteBackupPlanOutput, RusotoError<DeleteBackupPlanError>>;
async fn delete_backup_selection(
&self,
input: DeleteBackupSelectionInput,
) -> Result<(), RusotoError<DeleteBackupSelectionError>>;
async fn delete_backup_vault(
&self,
input: DeleteBackupVaultInput,
) -> Result<(), RusotoError<DeleteBackupVaultError>>;
async fn delete_backup_vault_access_policy(
&self,
input: DeleteBackupVaultAccessPolicyInput,
) -> Result<(), RusotoError<DeleteBackupVaultAccessPolicyError>>;
async fn delete_backup_vault_notifications(
&self,
input: DeleteBackupVaultNotificationsInput,
) -> Result<(), RusotoError<DeleteBackupVaultNotificationsError>>;
async fn delete_recovery_point(
&self,
input: DeleteRecoveryPointInput,
) -> Result<(), RusotoError<DeleteRecoveryPointError>>;
async fn describe_backup_job(
&self,
input: DescribeBackupJobInput,
) -> Result<DescribeBackupJobOutput, RusotoError<DescribeBackupJobError>>;
async fn describe_backup_vault(
&self,
input: DescribeBackupVaultInput,
) -> Result<DescribeBackupVaultOutput, RusotoError<DescribeBackupVaultError>>;
async fn describe_copy_job(
&self,
input: DescribeCopyJobInput,
) -> Result<DescribeCopyJobOutput, RusotoError<DescribeCopyJobError>>;
async fn describe_protected_resource(
&self,
input: DescribeProtectedResourceInput,
) -> Result<DescribeProtectedResourceOutput, RusotoError<DescribeProtectedResourceError>>;
async fn describe_recovery_point(
&self,
input: DescribeRecoveryPointInput,
) -> Result<DescribeRecoveryPointOutput, RusotoError<DescribeRecoveryPointError>>;
async fn describe_region_settings(
&self,
) -> Result<DescribeRegionSettingsOutput, RusotoError<DescribeRegionSettingsError>>;
async fn describe_restore_job(
&self,
input: DescribeRestoreJobInput,
) -> Result<DescribeRestoreJobOutput, RusotoError<DescribeRestoreJobError>>;
async fn export_backup_plan_template(
&self,
input: ExportBackupPlanTemplateInput,
) -> Result<ExportBackupPlanTemplateOutput, RusotoError<ExportBackupPlanTemplateError>>;
async fn get_backup_plan(
&self,
input: GetBackupPlanInput,
) -> Result<GetBackupPlanOutput, RusotoError<GetBackupPlanError>>;
async fn get_backup_plan_from_json(
&self,
input: GetBackupPlanFromJSONInput,
) -> Result<GetBackupPlanFromJSONOutput, RusotoError<GetBackupPlanFromJSONError>>;
async fn get_backup_plan_from_template(
&self,
input: GetBackupPlanFromTemplateInput,
) -> Result<GetBackupPlanFromTemplateOutput, RusotoError<GetBackupPlanFromTemplateError>>;
async fn get_backup_selection(
&self,
input: GetBackupSelectionInput,
) -> Result<GetBackupSelectionOutput, RusotoError<GetBackupSelectionError>>;
async fn get_backup_vault_access_policy(
&self,
input: GetBackupVaultAccessPolicyInput,
) -> Result<GetBackupVaultAccessPolicyOutput, RusotoError<GetBackupVaultAccessPolicyError>>;
async fn get_backup_vault_notifications(
&self,
input: GetBackupVaultNotificationsInput,
) -> Result<GetBackupVaultNotificationsOutput, RusotoError<GetBackupVaultNotificationsError>>;
async fn get_recovery_point_restore_metadata(
&self,
input: GetRecoveryPointRestoreMetadataInput,
) -> Result<
GetRecoveryPointRestoreMetadataOutput,
RusotoError<GetRecoveryPointRestoreMetadataError>,
>;
async fn get_supported_resource_types(
&self,
) -> Result<GetSupportedResourceTypesOutput, RusotoError<GetSupportedResourceTypesError>>;
async fn list_backup_jobs(
&self,
input: ListBackupJobsInput,
) -> Result<ListBackupJobsOutput, RusotoError<ListBackupJobsError>>;
async fn list_backup_plan_templates(
&self,
input: ListBackupPlanTemplatesInput,
) -> Result<ListBackupPlanTemplatesOutput, RusotoError<ListBackupPlanTemplatesError>>;
async fn list_backup_plan_versions(
&self,
input: ListBackupPlanVersionsInput,
) -> Result<ListBackupPlanVersionsOutput, RusotoError<ListBackupPlanVersionsError>>;
async fn list_backup_plans(
&self,
input: ListBackupPlansInput,
) -> Result<ListBackupPlansOutput, RusotoError<ListBackupPlansError>>;
async fn list_backup_selections(
&self,
input: ListBackupSelectionsInput,
) -> Result<ListBackupSelectionsOutput, RusotoError<ListBackupSelectionsError>>;
async fn list_backup_vaults(
&self,
input: ListBackupVaultsInput,
) -> Result<ListBackupVaultsOutput, RusotoError<ListBackupVaultsError>>;
async fn list_copy_jobs(
&self,
input: ListCopyJobsInput,
) -> Result<ListCopyJobsOutput, RusotoError<ListCopyJobsError>>;
async fn list_protected_resources(
&self,
input: ListProtectedResourcesInput,
) -> Result<ListProtectedResourcesOutput, RusotoError<ListProtectedResourcesError>>;
async fn list_recovery_points_by_backup_vault(
&self,
input: ListRecoveryPointsByBackupVaultInput,
) -> Result<
ListRecoveryPointsByBackupVaultOutput,
RusotoError<ListRecoveryPointsByBackupVaultError>,
>;
async fn list_recovery_points_by_resource(
&self,
input: ListRecoveryPointsByResourceInput,
) -> Result<ListRecoveryPointsByResourceOutput, RusotoError<ListRecoveryPointsByResourceError>>;
async fn list_restore_jobs(
&self,
input: ListRestoreJobsInput,
) -> Result<ListRestoreJobsOutput, RusotoError<ListRestoreJobsError>>;
async fn list_tags(
&self,
input: ListTagsInput,
) -> Result<ListTagsOutput, RusotoError<ListTagsError>>;
async fn put_backup_vault_access_policy(
&self,
input: PutBackupVaultAccessPolicyInput,
) -> Result<(), RusotoError<PutBackupVaultAccessPolicyError>>;
async fn put_backup_vault_notifications(
&self,
input: PutBackupVaultNotificationsInput,
) -> Result<(), RusotoError<PutBackupVaultNotificationsError>>;
async fn start_backup_job(
&self,
input: StartBackupJobInput,
) -> Result<StartBackupJobOutput, RusotoError<StartBackupJobError>>;
async fn start_copy_job(
&self,
input: StartCopyJobInput,
) -> Result<StartCopyJobOutput, RusotoError<StartCopyJobError>>;
async fn start_restore_job(
&self,
input: StartRestoreJobInput,
) -> Result<StartRestoreJobOutput, RusotoError<StartRestoreJobError>>;
async fn stop_backup_job(
&self,
input: StopBackupJobInput,
) -> Result<(), RusotoError<StopBackupJobError>>;
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_backup_plan(
&self,
input: UpdateBackupPlanInput,
) -> Result<UpdateBackupPlanOutput, RusotoError<UpdateBackupPlanError>>;
async fn update_recovery_point_lifecycle(
&self,
input: UpdateRecoveryPointLifecycleInput,
) -> Result<UpdateRecoveryPointLifecycleOutput, RusotoError<UpdateRecoveryPointLifecycleError>>;
async fn update_region_settings(
&self,
input: UpdateRegionSettingsInput,
) -> Result<(), RusotoError<UpdateRegionSettingsError>>;
}
#[derive(Clone)]
pub struct BackupClient {
client: Client,
region: region::Region,
}
impl BackupClient {
pub fn new(region: region::Region) -> BackupClient {
BackupClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> BackupClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
BackupClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> BackupClient {
BackupClient { client, region }
}
}
#[async_trait]
impl Backup for BackupClient {
#[allow(unused_mut)]
async fn create_backup_plan(
&self,
input: CreateBackupPlanInput,
) -> Result<CreateBackupPlanOutput, RusotoError<CreateBackupPlanError>> {
let request_uri = "/backup/plans/";
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateBackupPlanOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateBackupPlanError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_backup_selection(
&self,
input: CreateBackupSelectionInput,
) -> Result<CreateBackupSelectionOutput, RusotoError<CreateBackupSelectionError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}/selections/",
backup_plan_id = input.backup_plan_id
);
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateBackupSelectionOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateBackupSelectionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_backup_vault(
&self,
input: CreateBackupVaultInput,
) -> Result<CreateBackupVaultOutput, RusotoError<CreateBackupVaultError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateBackupVaultOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateBackupVaultError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_backup_plan(
&self,
input: DeleteBackupPlanInput,
) -> Result<DeleteBackupPlanOutput, RusotoError<DeleteBackupPlanError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}",
backup_plan_id = input.backup_plan_id
);
let mut request = SignedRequest::new("DELETE", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteBackupPlanOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteBackupPlanError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_backup_selection(
&self,
input: DeleteBackupSelectionInput,
) -> Result<(), RusotoError<DeleteBackupSelectionError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}/selections/{selection_id}",
backup_plan_id = input.backup_plan_id,
selection_id = input.selection_id
);
let mut request = SignedRequest::new("DELETE", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteBackupSelectionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_backup_vault(
&self,
input: DeleteBackupVaultInput,
) -> Result<(), RusotoError<DeleteBackupVaultError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("DELETE", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteBackupVaultError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_backup_vault_access_policy(
&self,
input: DeleteBackupVaultAccessPolicyInput,
) -> Result<(), RusotoError<DeleteBackupVaultAccessPolicyError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/access-policy",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("DELETE", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteBackupVaultAccessPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_backup_vault_notifications(
&self,
input: DeleteBackupVaultNotificationsInput,
) -> Result<(), RusotoError<DeleteBackupVaultNotificationsError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/notification-configuration",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("DELETE", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteBackupVaultNotificationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_recovery_point(
&self,
input: DeleteRecoveryPointInput,
) -> Result<(), RusotoError<DeleteRecoveryPointError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/recovery-points/{recovery_point_arn}",
backup_vault_name = input.backup_vault_name,
recovery_point_arn = input.recovery_point_arn
);
let mut request = SignedRequest::new("DELETE", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteRecoveryPointError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_backup_job(
&self,
input: DescribeBackupJobInput,
) -> Result<DescribeBackupJobOutput, RusotoError<DescribeBackupJobError>> {
let request_uri = format!(
"/backup-jobs/{backup_job_id}",
backup_job_id = input.backup_job_id
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeBackupJobOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeBackupJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_backup_vault(
&self,
input: DescribeBackupVaultInput,
) -> Result<DescribeBackupVaultOutput, RusotoError<DescribeBackupVaultError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeBackupVaultOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeBackupVaultError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_copy_job(
&self,
input: DescribeCopyJobInput,
) -> Result<DescribeCopyJobOutput, RusotoError<DescribeCopyJobError>> {
let request_uri = format!("/copy-jobs/{copy_job_id}", copy_job_id = input.copy_job_id);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCopyJobOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeCopyJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_protected_resource(
&self,
input: DescribeProtectedResourceInput,
) -> Result<DescribeProtectedResourceOutput, RusotoError<DescribeProtectedResourceError>> {
let request_uri = format!(
"/resources/{resource_arn}",
resource_arn = input.resource_arn
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeProtectedResourceOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeProtectedResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_recovery_point(
&self,
input: DescribeRecoveryPointInput,
) -> Result<DescribeRecoveryPointOutput, RusotoError<DescribeRecoveryPointError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/recovery-points/{recovery_point_arn}",
backup_vault_name = input.backup_vault_name,
recovery_point_arn = input.recovery_point_arn
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRecoveryPointOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeRecoveryPointError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_region_settings(
&self,
) -> Result<DescribeRegionSettingsOutput, RusotoError<DescribeRegionSettingsError>> {
let request_uri = "/account-settings";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRegionSettingsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeRegionSettingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn describe_restore_job(
&self,
input: DescribeRestoreJobInput,
) -> Result<DescribeRestoreJobOutput, RusotoError<DescribeRestoreJobError>> {
let request_uri = format!(
"/restore-jobs/{restore_job_id}",
restore_job_id = input.restore_job_id
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeRestoreJobOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DescribeRestoreJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn export_backup_plan_template(
&self,
input: ExportBackupPlanTemplateInput,
) -> Result<ExportBackupPlanTemplateOutput, RusotoError<ExportBackupPlanTemplateError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}/toTemplate/",
backup_plan_id = input.backup_plan_id
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ExportBackupPlanTemplateOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ExportBackupPlanTemplateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_backup_plan(
&self,
input: GetBackupPlanInput,
) -> Result<GetBackupPlanOutput, RusotoError<GetBackupPlanError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}/",
backup_plan_id = input.backup_plan_id
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.version_id {
params.put("versionId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBackupPlanOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBackupPlanError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_backup_plan_from_json(
&self,
input: GetBackupPlanFromJSONInput,
) -> Result<GetBackupPlanFromJSONOutput, RusotoError<GetBackupPlanFromJSONError>> {
let request_uri = "/backup/template/json/toPlan";
let mut request = SignedRequest::new("POST", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBackupPlanFromJSONOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBackupPlanFromJSONError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_backup_plan_from_template(
&self,
input: GetBackupPlanFromTemplateInput,
) -> Result<GetBackupPlanFromTemplateOutput, RusotoError<GetBackupPlanFromTemplateError>> {
let request_uri = format!(
"/backup/template/plans/{template_id}/toPlan",
template_id = input.backup_plan_template_id
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBackupPlanFromTemplateOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBackupPlanFromTemplateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_backup_selection(
&self,
input: GetBackupSelectionInput,
) -> Result<GetBackupSelectionOutput, RusotoError<GetBackupSelectionError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}/selections/{selection_id}",
backup_plan_id = input.backup_plan_id,
selection_id = input.selection_id
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBackupSelectionOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBackupSelectionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_backup_vault_access_policy(
&self,
input: GetBackupVaultAccessPolicyInput,
) -> Result<GetBackupVaultAccessPolicyOutput, RusotoError<GetBackupVaultAccessPolicyError>>
{
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/access-policy",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBackupVaultAccessPolicyOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBackupVaultAccessPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_backup_vault_notifications(
&self,
input: GetBackupVaultNotificationsInput,
) -> Result<GetBackupVaultNotificationsOutput, RusotoError<GetBackupVaultNotificationsError>>
{
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/notification-configuration",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetBackupVaultNotificationsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBackupVaultNotificationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_recovery_point_restore_metadata(
&self,
input: GetRecoveryPointRestoreMetadataInput,
) -> Result<
GetRecoveryPointRestoreMetadataOutput,
RusotoError<GetRecoveryPointRestoreMetadataError>,
> {
let request_uri = format!("/backup-vaults/{backup_vault_name}/recovery-points/{recovery_point_arn}/restore-metadata", backup_vault_name = input.backup_vault_name, recovery_point_arn = input.recovery_point_arn);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetRecoveryPointRestoreMetadataOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetRecoveryPointRestoreMetadataError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_supported_resource_types(
&self,
) -> Result<GetSupportedResourceTypesOutput, RusotoError<GetSupportedResourceTypesError>> {
let request_uri = "/supported-resource-types";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetSupportedResourceTypesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetSupportedResourceTypesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_backup_jobs(
&self,
input: ListBackupJobsInput,
) -> Result<ListBackupJobsOutput, RusotoError<ListBackupJobsError>> {
let request_uri = "/backup-jobs/";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.by_account_id {
params.put("accountId", x);
}
if let Some(ref x) = input.by_backup_vault_name {
params.put("backupVaultName", x);
}
if let Some(ref x) = input.by_created_after {
params.put("createdAfter", x);
}
if let Some(ref x) = input.by_created_before {
params.put("createdBefore", x);
}
if let Some(ref x) = input.by_resource_arn {
params.put("resourceArn", x);
}
if let Some(ref x) = input.by_resource_type {
params.put("resourceType", x);
}
if let Some(ref x) = input.by_state {
params.put("state", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBackupJobsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBackupJobsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_backup_plan_templates(
&self,
input: ListBackupPlanTemplatesInput,
) -> Result<ListBackupPlanTemplatesOutput, RusotoError<ListBackupPlanTemplatesError>> {
let request_uri = "/backup/template/plans";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBackupPlanTemplatesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBackupPlanTemplatesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_backup_plan_versions(
&self,
input: ListBackupPlanVersionsInput,
) -> Result<ListBackupPlanVersionsOutput, RusotoError<ListBackupPlanVersionsError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}/versions/",
backup_plan_id = input.backup_plan_id
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBackupPlanVersionsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBackupPlanVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_backup_plans(
&self,
input: ListBackupPlansInput,
) -> Result<ListBackupPlansOutput, RusotoError<ListBackupPlansError>> {
let request_uri = "/backup/plans/";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.include_deleted {
params.put("includeDeleted", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBackupPlansOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBackupPlansError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_backup_selections(
&self,
input: ListBackupSelectionsInput,
) -> Result<ListBackupSelectionsOutput, RusotoError<ListBackupSelectionsError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}/selections/",
backup_plan_id = input.backup_plan_id
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBackupSelectionsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBackupSelectionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_backup_vaults(
&self,
input: ListBackupVaultsInput,
) -> Result<ListBackupVaultsOutput, RusotoError<ListBackupVaultsError>> {
let request_uri = "/backup-vaults/";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBackupVaultsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBackupVaultsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_copy_jobs(
&self,
input: ListCopyJobsInput,
) -> Result<ListCopyJobsOutput, RusotoError<ListCopyJobsError>> {
let request_uri = "/copy-jobs/";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.by_account_id {
params.put("accountId", x);
}
if let Some(ref x) = input.by_created_after {
params.put("createdAfter", x);
}
if let Some(ref x) = input.by_created_before {
params.put("createdBefore", x);
}
if let Some(ref x) = input.by_destination_vault_arn {
params.put("destinationVaultArn", x);
}
if let Some(ref x) = input.by_resource_arn {
params.put("resourceArn", x);
}
if let Some(ref x) = input.by_resource_type {
params.put("resourceType", x);
}
if let Some(ref x) = input.by_state {
params.put("state", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListCopyJobsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListCopyJobsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_protected_resources(
&self,
input: ListProtectedResourcesInput,
) -> Result<ListProtectedResourcesOutput, RusotoError<ListProtectedResourcesError>> {
let request_uri = "/resources/";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListProtectedResourcesOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListProtectedResourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_recovery_points_by_backup_vault(
&self,
input: ListRecoveryPointsByBackupVaultInput,
) -> Result<
ListRecoveryPointsByBackupVaultOutput,
RusotoError<ListRecoveryPointsByBackupVaultError>,
> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/recovery-points/",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.by_backup_plan_id {
params.put("backupPlanId", x);
}
if let Some(ref x) = input.by_created_after {
params.put("createdAfter", x);
}
if let Some(ref x) = input.by_created_before {
params.put("createdBefore", x);
}
if let Some(ref x) = input.by_resource_arn {
params.put("resourceArn", x);
}
if let Some(ref x) = input.by_resource_type {
params.put("resourceType", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRecoveryPointsByBackupVaultOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRecoveryPointsByBackupVaultError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_recovery_points_by_resource(
&self,
input: ListRecoveryPointsByResourceInput,
) -> Result<ListRecoveryPointsByResourceOutput, RusotoError<ListRecoveryPointsByResourceError>>
{
let request_uri = format!(
"/resources/{resource_arn}/recovery-points/",
resource_arn = input.resource_arn
);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRecoveryPointsByResourceOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRecoveryPointsByResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_restore_jobs(
&self,
input: ListRestoreJobsInput,
) -> Result<ListRestoreJobsOutput, RusotoError<ListRestoreJobsError>> {
let request_uri = "/restore-jobs/";
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.by_account_id {
params.put("accountId", x);
}
if let Some(ref x) = input.by_created_after {
params.put("createdAfter", x);
}
if let Some(ref x) = input.by_created_before {
params.put("createdBefore", x);
}
if let Some(ref x) = input.by_status {
params.put("status", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListRestoreJobsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListRestoreJobsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags(
&self,
input: ListTagsInput,
) -> Result<ListTagsOutput, RusotoError<ListTagsError>> {
let request_uri = format!("/tags/{resource_arn}/", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_backup_vault_access_policy(
&self,
input: PutBackupVaultAccessPolicyInput,
) -> Result<(), RusotoError<PutBackupVaultAccessPolicyError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/access-policy",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutBackupVaultAccessPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_backup_vault_notifications(
&self,
input: PutBackupVaultNotificationsInput,
) -> Result<(), RusotoError<PutBackupVaultNotificationsError>> {
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/notification-configuration",
backup_vault_name = input.backup_vault_name
);
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutBackupVaultNotificationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_backup_job(
&self,
input: StartBackupJobInput,
) -> Result<StartBackupJobOutput, RusotoError<StartBackupJobError>> {
let request_uri = "/backup-jobs";
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartBackupJobOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartBackupJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_copy_job(
&self,
input: StartCopyJobInput,
) -> Result<StartCopyJobOutput, RusotoError<StartCopyJobError>> {
let request_uri = "/copy-jobs";
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartCopyJobOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartCopyJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_restore_job(
&self,
input: StartRestoreJobInput,
) -> Result<StartRestoreJobOutput, RusotoError<StartRestoreJobError>> {
let request_uri = "/restore-jobs";
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartRestoreJobOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartRestoreJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn stop_backup_job(
&self,
input: StopBackupJobInput,
) -> Result<(), RusotoError<StopBackupJobError>> {
let request_uri = format!(
"/backup-jobs/{backup_job_id}",
backup_job_id = input.backup_job_id
);
let mut request = SignedRequest::new("POST", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StopBackupJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/untag/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_backup_plan(
&self,
input: UpdateBackupPlanInput,
) -> Result<UpdateBackupPlanOutput, RusotoError<UpdateBackupPlanError>> {
let request_uri = format!(
"/backup/plans/{backup_plan_id}",
backup_plan_id = input.backup_plan_id
);
let mut request = SignedRequest::new("POST", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateBackupPlanOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateBackupPlanError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_recovery_point_lifecycle(
&self,
input: UpdateRecoveryPointLifecycleInput,
) -> Result<UpdateRecoveryPointLifecycleOutput, RusotoError<UpdateRecoveryPointLifecycleError>>
{
let request_uri = format!(
"/backup-vaults/{backup_vault_name}/recovery-points/{recovery_point_arn}",
backup_vault_name = input.backup_vault_name,
recovery_point_arn = input.recovery_point_arn
);
let mut request = SignedRequest::new("POST", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateRecoveryPointLifecycleOutput, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateRecoveryPointLifecycleError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_region_settings(
&self,
input: UpdateRegionSettingsInput,
) -> Result<(), RusotoError<UpdateRegionSettingsError>> {
let request_uri = "/account-settings";
let mut request = SignedRequest::new("PUT", "backup", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateRegionSettingsError::from_response(response))
}
}
}