#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_legal_hold_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CancelLegalHoldOutput, crate::error::CancelLegalHoldError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CancelLegalHoldError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CancelLegalHoldError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::CancelLegalHoldError {
meta: generic,
kind: crate::error::CancelLegalHoldErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidResourceStateException" => crate::error::CancelLegalHoldError {
meta: generic,
kind: crate::error::CancelLegalHoldErrorKind::InvalidResourceStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_resource_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_resource_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::CancelLegalHoldError {
meta: generic,
kind: crate::error::CancelLegalHoldErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::CancelLegalHoldError {
meta: generic,
kind: crate::error::CancelLegalHoldErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::CancelLegalHoldError {
meta: generic,
kind: crate::error::CancelLegalHoldErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CancelLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CancelLegalHoldError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_cancel_legal_hold_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CancelLegalHoldOutput, crate::error::CancelLegalHoldError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::cancel_legal_hold_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_backup_plan_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateBackupPlanOutput, crate::error::CreateBackupPlanError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateBackupPlanError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateBackupPlanError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AlreadyExistsException" => crate::error::CreateBackupPlanError {
meta: generic,
kind: crate::error::CreateBackupPlanErrorKind::AlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterValueException" => crate::error::CreateBackupPlanError {
meta: generic,
kind: crate::error::CreateBackupPlanErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateBackupPlanError {
meta: generic,
kind: crate::error::CreateBackupPlanErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::CreateBackupPlanError {
meta: generic,
kind: crate::error::CreateBackupPlanErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::CreateBackupPlanError {
meta: generic,
kind: crate::error::CreateBackupPlanErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateBackupPlanError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_backup_plan_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateBackupPlanOutput, crate::error::CreateBackupPlanError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_backup_plan_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_backup_plan(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateBackupPlanError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_backup_selection_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateBackupSelectionOutput,
crate::error::CreateBackupSelectionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateBackupSelectionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateBackupSelectionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AlreadyExistsException" => crate::error::CreateBackupSelectionError {
meta: generic,
kind: crate::error::CreateBackupSelectionErrorKind::AlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterValueException" => crate::error::CreateBackupSelectionError {
meta: generic,
kind: crate::error::CreateBackupSelectionErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateBackupSelectionError {
meta: generic,
kind: crate::error::CreateBackupSelectionErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::CreateBackupSelectionError {
meta: generic,
kind: crate::error::CreateBackupSelectionErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::CreateBackupSelectionError {
meta: generic,
kind: crate::error::CreateBackupSelectionErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateBackupSelectionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_backup_selection_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::CreateBackupSelectionOutput,
crate::error::CreateBackupSelectionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_backup_selection_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_backup_selection(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateBackupSelectionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_backup_vault_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateBackupVaultOutput, crate::error::CreateBackupVaultError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateBackupVaultError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateBackupVaultError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AlreadyExistsException" => crate::error::CreateBackupVaultError {
meta: generic,
kind: crate::error::CreateBackupVaultErrorKind::AlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterValueException" => crate::error::CreateBackupVaultError {
meta: generic,
kind: crate::error::CreateBackupVaultErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateBackupVaultError {
meta: generic,
kind: crate::error::CreateBackupVaultErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::CreateBackupVaultError {
meta: generic,
kind: crate::error::CreateBackupVaultErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::CreateBackupVaultError {
meta: generic,
kind: crate::error::CreateBackupVaultErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateBackupVaultError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_backup_vault_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateBackupVaultOutput, crate::error::CreateBackupVaultError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_backup_vault_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_backup_vault(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateBackupVaultError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_framework_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFrameworkOutput, crate::error::CreateFrameworkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateFrameworkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateFrameworkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AlreadyExistsException" => crate::error::CreateFrameworkError {
meta: generic,
kind: crate::error::CreateFrameworkErrorKind::AlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterValueException" => crate::error::CreateFrameworkError {
meta: generic,
kind: crate::error::CreateFrameworkErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateFrameworkError {
meta: generic,
kind: crate::error::CreateFrameworkErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::CreateFrameworkError {
meta: generic,
kind: crate::error::CreateFrameworkErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::CreateFrameworkError {
meta: generic,
kind: crate::error::CreateFrameworkErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateFrameworkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_framework_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateFrameworkOutput, crate::error::CreateFrameworkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_framework_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_framework(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateFrameworkError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_legal_hold_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateLegalHoldOutput, crate::error::CreateLegalHoldError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateLegalHoldError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateLegalHoldError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::CreateLegalHoldError {
meta: generic,
kind: crate::error::CreateLegalHoldErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateLegalHoldError {
meta: generic,
kind: crate::error::CreateLegalHoldErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::CreateLegalHoldError {
meta: generic,
kind: crate::error::CreateLegalHoldErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::CreateLegalHoldError {
meta: generic,
kind: crate::error::CreateLegalHoldErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateLegalHoldError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_legal_hold_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateLegalHoldOutput, crate::error::CreateLegalHoldError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_legal_hold_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_legal_hold(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateLegalHoldError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_report_plan_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateReportPlanOutput, crate::error::CreateReportPlanError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::CreateReportPlanError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::CreateReportPlanError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AlreadyExistsException" => crate::error::CreateReportPlanError {
meta: generic,
kind: crate::error::CreateReportPlanErrorKind::AlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterValueException" => crate::error::CreateReportPlanError {
meta: generic,
kind: crate::error::CreateReportPlanErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::CreateReportPlanError {
meta: generic,
kind: crate::error::CreateReportPlanErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::CreateReportPlanError {
meta: generic,
kind: crate::error::CreateReportPlanErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::CreateReportPlanError {
meta: generic,
kind: crate::error::CreateReportPlanErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::CreateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::CreateReportPlanError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_create_report_plan_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::CreateReportPlanOutput, crate::error::CreateReportPlanError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::create_report_plan_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_create_report_plan(
response.body().as_ref(),
output,
)
.map_err(crate::error::CreateReportPlanError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_plan_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteBackupPlanOutput, crate::error::DeleteBackupPlanError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteBackupPlanError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteBackupPlanError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DeleteBackupPlanError {
meta: generic,
kind: crate::error::DeleteBackupPlanErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DeleteBackupPlanError {
meta: generic,
kind: crate::error::DeleteBackupPlanErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DeleteBackupPlanError {
meta: generic,
kind: crate::error::DeleteBackupPlanErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteBackupPlanError {
meta: generic,
kind: crate::error::DeleteBackupPlanErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DeleteBackupPlanError {
meta: generic,
kind: crate::error::DeleteBackupPlanErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteBackupPlanError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_plan_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteBackupPlanOutput, crate::error::DeleteBackupPlanError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_backup_plan_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_delete_backup_plan(
response.body().as_ref(),
output,
)
.map_err(crate::error::DeleteBackupPlanError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_selection_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteBackupSelectionOutput,
crate::error::DeleteBackupSelectionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteBackupSelectionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteBackupSelectionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DeleteBackupSelectionError {
meta: generic,
kind: crate::error::DeleteBackupSelectionErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DeleteBackupSelectionError {
meta: generic,
kind: crate::error::DeleteBackupSelectionErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteBackupSelectionError {
meta: generic,
kind: crate::error::DeleteBackupSelectionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DeleteBackupSelectionError {
meta: generic,
kind: crate::error::DeleteBackupSelectionErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteBackupSelectionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_selection_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteBackupSelectionOutput,
crate::error::DeleteBackupSelectionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_backup_selection_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_vault_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteBackupVaultOutput, crate::error::DeleteBackupVaultError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteBackupVaultError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteBackupVaultError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DeleteBackupVaultError {
meta: generic,
kind: crate::error::DeleteBackupVaultErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DeleteBackupVaultError {
meta: generic,
kind: crate::error::DeleteBackupVaultErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DeleteBackupVaultError {
meta: generic,
kind: crate::error::DeleteBackupVaultErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteBackupVaultError {
meta: generic,
kind: crate::error::DeleteBackupVaultErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DeleteBackupVaultError {
meta: generic,
kind: crate::error::DeleteBackupVaultErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteBackupVaultError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_vault_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteBackupVaultOutput, crate::error::DeleteBackupVaultError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_backup_vault_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_vault_access_policy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteBackupVaultAccessPolicyOutput,
crate::error::DeleteBackupVaultAccessPolicyError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteBackupVaultAccessPolicyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteBackupVaultAccessPolicyError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DeleteBackupVaultAccessPolicyError {
meta: generic,
kind:
crate::error::DeleteBackupVaultAccessPolicyErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::DeleteBackupVaultAccessPolicyError {
meta: generic,
kind:
crate::error::DeleteBackupVaultAccessPolicyErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::DeleteBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::DeleteBackupVaultAccessPolicyErrorKind::ResourceNotFoundException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ServiceUnavailableException" => crate::error::DeleteBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::DeleteBackupVaultAccessPolicyErrorKind::ServiceUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::DeleteBackupVaultAccessPolicyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_vault_access_policy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteBackupVaultAccessPolicyOutput,
crate::error::DeleteBackupVaultAccessPolicyError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::delete_backup_vault_access_policy_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_vault_lock_configuration_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteBackupVaultLockConfigurationOutput,
crate::error::DeleteBackupVaultLockConfigurationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteBackupVaultLockConfigurationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DeleteBackupVaultLockConfigurationError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DeleteBackupVaultLockConfigurationError { meta: generic, kind: crate::error::DeleteBackupVaultLockConfigurationErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidRequestException" => crate::error::DeleteBackupVaultLockConfigurationError { meta: generic, kind: crate::error::DeleteBackupVaultLockConfigurationErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"MissingParameterValueException" => crate::error::DeleteBackupVaultLockConfigurationError { meta: generic, kind: crate::error::DeleteBackupVaultLockConfigurationErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::DeleteBackupVaultLockConfigurationError { meta: generic, kind: crate::error::DeleteBackupVaultLockConfigurationErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceUnavailableException" => crate::error::DeleteBackupVaultLockConfigurationError { meta: generic, kind: crate::error::DeleteBackupVaultLockConfigurationErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::DeleteBackupVaultLockConfigurationError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_vault_lock_configuration_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteBackupVaultLockConfigurationOutput,
crate::error::DeleteBackupVaultLockConfigurationError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::delete_backup_vault_lock_configuration_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_vault_notifications_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteBackupVaultNotificationsOutput,
crate::error::DeleteBackupVaultNotificationsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteBackupVaultNotificationsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteBackupVaultNotificationsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DeleteBackupVaultNotificationsError { meta: generic, kind: crate::error::DeleteBackupVaultNotificationsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultNotificationsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"MissingParameterValueException" => crate::error::DeleteBackupVaultNotificationsError { meta: generic, kind: crate::error::DeleteBackupVaultNotificationsErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultNotificationsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::DeleteBackupVaultNotificationsError { meta: generic, kind: crate::error::DeleteBackupVaultNotificationsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultNotificationsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceUnavailableException" => crate::error::DeleteBackupVaultNotificationsError { meta: generic, kind: crate::error::DeleteBackupVaultNotificationsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteBackupVaultNotificationsError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::DeleteBackupVaultNotificationsError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_backup_vault_notifications_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteBackupVaultNotificationsOutput,
crate::error::DeleteBackupVaultNotificationsError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::delete_backup_vault_notifications_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_framework_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFrameworkOutput, crate::error::DeleteFrameworkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteFrameworkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteFrameworkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ConflictException" => {
crate::error::DeleteFrameworkError {
meta: generic,
kind: crate::error::DeleteFrameworkErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterValueException" => crate::error::DeleteFrameworkError {
meta: generic,
kind: crate::error::DeleteFrameworkErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DeleteFrameworkError {
meta: generic,
kind: crate::error::DeleteFrameworkErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteFrameworkError {
meta: generic,
kind: crate::error::DeleteFrameworkErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DeleteFrameworkError {
meta: generic,
kind: crate::error::DeleteFrameworkErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteFrameworkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_framework_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteFrameworkOutput, crate::error::DeleteFrameworkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_framework_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_recovery_point_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteRecoveryPointOutput,
crate::error::DeleteRecoveryPointError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteRecoveryPointError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteRecoveryPointError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DeleteRecoveryPointError {
meta: generic,
kind: crate::error::DeleteRecoveryPointErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::DeleteRecoveryPointError {
meta: generic,
kind: crate::error::DeleteRecoveryPointErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidResourceStateException" => crate::error::DeleteRecoveryPointError {
meta: generic,
kind: crate::error::DeleteRecoveryPointErrorKind::InvalidResourceStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_resource_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_resource_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DeleteRecoveryPointError {
meta: generic,
kind: crate::error::DeleteRecoveryPointErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteRecoveryPointError {
meta: generic,
kind: crate::error::DeleteRecoveryPointErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DeleteRecoveryPointError {
meta: generic,
kind: crate::error::DeleteRecoveryPointErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteRecoveryPointError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_recovery_point_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DeleteRecoveryPointOutput,
crate::error::DeleteRecoveryPointError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_recovery_point_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_report_plan_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteReportPlanOutput, crate::error::DeleteReportPlanError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteReportPlanError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteReportPlanError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ConflictException" => {
crate::error::DeleteReportPlanError {
meta: generic,
kind: crate::error::DeleteReportPlanErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterValueException" => crate::error::DeleteReportPlanError {
meta: generic,
kind: crate::error::DeleteReportPlanErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DeleteReportPlanError {
meta: generic,
kind: crate::error::DeleteReportPlanErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteReportPlanError {
meta: generic,
kind: crate::error::DeleteReportPlanErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DeleteReportPlanError {
meta: generic,
kind: crate::error::DeleteReportPlanErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteReportPlanError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_report_plan_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteReportPlanOutput, crate::error::DeleteReportPlanError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_report_plan_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_backup_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeBackupJobOutput, crate::error::DescribeBackupJobError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeBackupJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeBackupJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"DependencyFailureException" => crate::error::DescribeBackupJobError {
meta: generic,
kind: crate::error::DescribeBackupJobErrorKind::DependencyFailureException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::dependency_failure_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_dependency_failure_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterValueException" => crate::error::DescribeBackupJobError {
meta: generic,
kind: crate::error::DescribeBackupJobErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DescribeBackupJobError {
meta: generic,
kind: crate::error::DescribeBackupJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeBackupJobError {
meta: generic,
kind: crate::error::DescribeBackupJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeBackupJobError {
meta: generic,
kind: crate::error::DescribeBackupJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeBackupJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_backup_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeBackupJobOutput, crate::error::DescribeBackupJobError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_backup_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_backup_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeBackupJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_backup_vault_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeBackupVaultOutput,
crate::error::DescribeBackupVaultError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeBackupVaultError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeBackupVaultError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DescribeBackupVaultError {
meta: generic,
kind: crate::error::DescribeBackupVaultErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DescribeBackupVaultError {
meta: generic,
kind: crate::error::DescribeBackupVaultErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeBackupVaultError {
meta: generic,
kind: crate::error::DescribeBackupVaultErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeBackupVaultError {
meta: generic,
kind: crate::error::DescribeBackupVaultErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeBackupVaultError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeBackupVaultError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_backup_vault_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeBackupVaultOutput,
crate::error::DescribeBackupVaultError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_backup_vault_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_backup_vault(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeBackupVaultError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_copy_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeCopyJobOutput, crate::error::DescribeCopyJobError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeCopyJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeCopyJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DescribeCopyJobError {
meta: generic,
kind: crate::error::DescribeCopyJobErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DescribeCopyJobError {
meta: generic,
kind: crate::error::DescribeCopyJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeCopyJobError {
meta: generic,
kind: crate::error::DescribeCopyJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeCopyJobError {
meta: generic,
kind: crate::error::DescribeCopyJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeCopyJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_copy_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeCopyJobOutput, crate::error::DescribeCopyJobError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_copy_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_copy_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeCopyJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_framework_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFrameworkOutput, crate::error::DescribeFrameworkError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeFrameworkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeFrameworkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DescribeFrameworkError {
meta: generic,
kind: crate::error::DescribeFrameworkErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DescribeFrameworkError {
meta: generic,
kind: crate::error::DescribeFrameworkErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeFrameworkError {
meta: generic,
kind: crate::error::DescribeFrameworkErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeFrameworkError {
meta: generic,
kind: crate::error::DescribeFrameworkErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeFrameworkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_framework_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeFrameworkOutput, crate::error::DescribeFrameworkError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_framework_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_framework(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeFrameworkError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_global_settings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeGlobalSettingsOutput,
crate::error::DescribeGlobalSettingsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeGlobalSettingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeGlobalSettingsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidRequestException" => crate::error::DescribeGlobalSettingsError {
meta: generic,
kind: crate::error::DescribeGlobalSettingsErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeGlobalSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeGlobalSettingsError {
meta: generic,
kind: crate::error::DescribeGlobalSettingsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeGlobalSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeGlobalSettingsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_global_settings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeGlobalSettingsOutput,
crate::error::DescribeGlobalSettingsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_global_settings_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_global_settings(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeGlobalSettingsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_protected_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeProtectedResourceOutput,
crate::error::DescribeProtectedResourceError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeProtectedResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeProtectedResourceError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DescribeProtectedResourceError {
meta: generic,
kind: crate::error::DescribeProtectedResourceErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeProtectedResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::DescribeProtectedResourceError {
meta: generic,
kind: crate::error::DescribeProtectedResourceErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeProtectedResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::DescribeProtectedResourceError {
meta: generic,
kind: crate::error::DescribeProtectedResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeProtectedResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeProtectedResourceError {
meta: generic,
kind: crate::error::DescribeProtectedResourceErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeProtectedResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeProtectedResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_protected_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeProtectedResourceOutput,
crate::error::DescribeProtectedResourceError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_protected_resource_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_protected_resource(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeProtectedResourceError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_recovery_point_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRecoveryPointOutput,
crate::error::DescribeRecoveryPointError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeRecoveryPointError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeRecoveryPointError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DescribeRecoveryPointError {
meta: generic,
kind: crate::error::DescribeRecoveryPointErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DescribeRecoveryPointError {
meta: generic,
kind: crate::error::DescribeRecoveryPointErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeRecoveryPointError {
meta: generic,
kind: crate::error::DescribeRecoveryPointErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeRecoveryPointError {
meta: generic,
kind: crate::error::DescribeRecoveryPointErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeRecoveryPointError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_recovery_point_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRecoveryPointOutput,
crate::error::DescribeRecoveryPointError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_recovery_point_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_recovery_point(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeRecoveryPointError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_region_settings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRegionSettingsOutput,
crate::error::DescribeRegionSettingsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeRegionSettingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DescribeRegionSettingsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ServiceUnavailableException" => crate::error::DescribeRegionSettingsError {
meta: generic,
kind: crate::error::DescribeRegionSettingsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRegionSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeRegionSettingsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_region_settings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRegionSettingsOutput,
crate::error::DescribeRegionSettingsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_region_settings_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_region_settings(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeRegionSettingsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_report_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeReportJobOutput, crate::error::DescribeReportJobError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeReportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeReportJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"MissingParameterValueException" => crate::error::DescribeReportJobError {
meta: generic,
kind: crate::error::DescribeReportJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeReportJobError {
meta: generic,
kind: crate::error::DescribeReportJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeReportJobError {
meta: generic,
kind: crate::error::DescribeReportJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeReportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_report_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DescribeReportJobOutput, crate::error::DescribeReportJobError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_report_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_report_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeReportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_report_plan_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeReportPlanOutput,
crate::error::DescribeReportPlanError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeReportPlanError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeReportPlanError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DescribeReportPlanError {
meta: generic,
kind: crate::error::DescribeReportPlanErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DescribeReportPlanError {
meta: generic,
kind: crate::error::DescribeReportPlanErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeReportPlanError {
meta: generic,
kind: crate::error::DescribeReportPlanErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeReportPlanError {
meta: generic,
kind: crate::error::DescribeReportPlanErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeReportPlanError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_report_plan_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeReportPlanOutput,
crate::error::DescribeReportPlanError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_report_plan_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_report_plan(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeReportPlanError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_restore_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRestoreJobOutput,
crate::error::DescribeRestoreJobError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeRestoreJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeRestoreJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"DependencyFailureException" => crate::error::DescribeRestoreJobError {
meta: generic,
kind: crate::error::DescribeRestoreJobErrorKind::DependencyFailureException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::dependency_failure_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_dependency_failure_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterValueException" => crate::error::DescribeRestoreJobError {
meta: generic,
kind: crate::error::DescribeRestoreJobErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::DescribeRestoreJobError {
meta: generic,
kind: crate::error::DescribeRestoreJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeRestoreJobError {
meta: generic,
kind: crate::error::DescribeRestoreJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DescribeRestoreJobError {
meta: generic,
kind: crate::error::DescribeRestoreJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeRestoreJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_restore_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeRestoreJobOutput,
crate::error::DescribeRestoreJobError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_restore_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_restore_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeRestoreJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_recovery_point_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DisassociateRecoveryPointOutput,
crate::error::DisassociateRecoveryPointError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DisassociateRecoveryPointError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DisassociateRecoveryPointError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DisassociateRecoveryPointError {
meta: generic,
kind: crate::error::DisassociateRecoveryPointErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"InvalidRequestException" => crate::error::DisassociateRecoveryPointError {
meta: generic,
kind: crate::error::DisassociateRecoveryPointErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidResourceStateException" => crate::error::DisassociateRecoveryPointError {
meta: generic,
kind: crate::error::DisassociateRecoveryPointErrorKind::InvalidResourceStateException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_resource_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_resource_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::DisassociateRecoveryPointError {
meta: generic,
kind: crate::error::DisassociateRecoveryPointErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::DisassociateRecoveryPointError {
meta: generic,
kind: crate::error::DisassociateRecoveryPointErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::DisassociateRecoveryPointError {
meta: generic,
kind: crate::error::DisassociateRecoveryPointErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DisassociateRecoveryPointError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_recovery_point_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DisassociateRecoveryPointOutput,
crate::error::DisassociateRecoveryPointError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::disassociate_recovery_point_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_recovery_point_from_parent_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DisassociateRecoveryPointFromParentOutput,
crate::error::DisassociateRecoveryPointFromParentError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DisassociateRecoveryPointFromParentError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::DisassociateRecoveryPointFromParentError::unhandled(generic))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::DisassociateRecoveryPointFromParentError { meta: generic, kind: crate::error::DisassociateRecoveryPointFromParentErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointFromParentError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidRequestException" => crate::error::DisassociateRecoveryPointFromParentError { meta: generic, kind: crate::error::DisassociateRecoveryPointFromParentErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointFromParentError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"MissingParameterValueException" => crate::error::DisassociateRecoveryPointFromParentError { meta: generic, kind: crate::error::DisassociateRecoveryPointFromParentErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointFromParentError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::DisassociateRecoveryPointFromParentError { meta: generic, kind: crate::error::DisassociateRecoveryPointFromParentErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointFromParentError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceUnavailableException" => crate::error::DisassociateRecoveryPointFromParentError { meta: generic, kind: crate::error::DisassociateRecoveryPointFromParentErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DisassociateRecoveryPointFromParentError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::DisassociateRecoveryPointFromParentError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_disassociate_recovery_point_from_parent_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DisassociateRecoveryPointFromParentOutput,
crate::error::DisassociateRecoveryPointFromParentError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::disassociate_recovery_point_from_parent_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_backup_plan_template_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ExportBackupPlanTemplateOutput,
crate::error::ExportBackupPlanTemplateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ExportBackupPlanTemplateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ExportBackupPlanTemplateError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ExportBackupPlanTemplateError {
meta: generic,
kind: crate::error::ExportBackupPlanTemplateErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExportBackupPlanTemplateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::ExportBackupPlanTemplateError {
meta: generic,
kind: crate::error::ExportBackupPlanTemplateErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExportBackupPlanTemplateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::ExportBackupPlanTemplateError {
meta: generic,
kind: crate::error::ExportBackupPlanTemplateErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExportBackupPlanTemplateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ExportBackupPlanTemplateError {
meta: generic,
kind: crate::error::ExportBackupPlanTemplateErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExportBackupPlanTemplateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ExportBackupPlanTemplateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_backup_plan_template_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ExportBackupPlanTemplateOutput,
crate::error::ExportBackupPlanTemplateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::export_backup_plan_template_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_export_backup_plan_template(
response.body().as_ref(),
output,
)
.map_err(crate::error::ExportBackupPlanTemplateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_plan_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetBackupPlanOutput, crate::error::GetBackupPlanError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetBackupPlanError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetBackupPlanError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::GetBackupPlanError {
meta: generic,
kind: crate::error::GetBackupPlanErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::GetBackupPlanError {
meta: generic,
kind: crate::error::GetBackupPlanErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetBackupPlanError {
meta: generic,
kind: crate::error::GetBackupPlanErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::GetBackupPlanError {
meta: generic,
kind: crate::error::GetBackupPlanErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetBackupPlanError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_plan_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetBackupPlanOutput, crate::error::GetBackupPlanError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_backup_plan_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_backup_plan(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetBackupPlanError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_plan_from_json_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupPlanFromJsonOutput,
crate::error::GetBackupPlanFromJSONError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetBackupPlanFromJSONError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetBackupPlanFromJSONError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::GetBackupPlanFromJSONError {
meta: generic,
kind: crate::error::GetBackupPlanFromJSONErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromJSONError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::GetBackupPlanFromJSONError {
meta: generic,
kind: crate::error::GetBackupPlanFromJSONErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromJSONError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::GetBackupPlanFromJSONError {
meta: generic,
kind: crate::error::GetBackupPlanFromJSONErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromJSONError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::GetBackupPlanFromJSONError {
meta: generic,
kind: crate::error::GetBackupPlanFromJSONErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromJSONError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::GetBackupPlanFromJSONError {
meta: generic,
kind: crate::error::GetBackupPlanFromJSONErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromJSONError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetBackupPlanFromJSONError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_plan_from_json_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupPlanFromJsonOutput,
crate::error::GetBackupPlanFromJSONError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_backup_plan_from_json_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_backup_plan_from_json(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetBackupPlanFromJSONError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_plan_from_template_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupPlanFromTemplateOutput,
crate::error::GetBackupPlanFromTemplateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetBackupPlanFromTemplateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetBackupPlanFromTemplateError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::GetBackupPlanFromTemplateError {
meta: generic,
kind: crate::error::GetBackupPlanFromTemplateErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromTemplateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::GetBackupPlanFromTemplateError {
meta: generic,
kind: crate::error::GetBackupPlanFromTemplateErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromTemplateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::GetBackupPlanFromTemplateError {
meta: generic,
kind: crate::error::GetBackupPlanFromTemplateErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromTemplateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::GetBackupPlanFromTemplateError {
meta: generic,
kind: crate::error::GetBackupPlanFromTemplateErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupPlanFromTemplateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetBackupPlanFromTemplateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_plan_from_template_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupPlanFromTemplateOutput,
crate::error::GetBackupPlanFromTemplateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_backup_plan_from_template_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_backup_plan_from_template(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetBackupPlanFromTemplateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_selection_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupSelectionOutput,
crate::error::GetBackupSelectionError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetBackupSelectionError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetBackupSelectionError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::GetBackupSelectionError {
meta: generic,
kind: crate::error::GetBackupSelectionErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::GetBackupSelectionError {
meta: generic,
kind: crate::error::GetBackupSelectionErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetBackupSelectionError {
meta: generic,
kind: crate::error::GetBackupSelectionErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::GetBackupSelectionError {
meta: generic,
kind: crate::error::GetBackupSelectionErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupSelectionError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetBackupSelectionError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_selection_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupSelectionOutput,
crate::error::GetBackupSelectionError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_backup_selection_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_backup_selection(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetBackupSelectionError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_vault_access_policy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupVaultAccessPolicyOutput,
crate::error::GetBackupVaultAccessPolicyError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetBackupVaultAccessPolicyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetBackupVaultAccessPolicyError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::GetBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::GetBackupVaultAccessPolicyErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::GetBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::GetBackupVaultAccessPolicyErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::GetBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::GetBackupVaultAccessPolicyErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::GetBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::GetBackupVaultAccessPolicyErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetBackupVaultAccessPolicyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_vault_access_policy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupVaultAccessPolicyOutput,
crate::error::GetBackupVaultAccessPolicyError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_backup_vault_access_policy_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_backup_vault_access_policy(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetBackupVaultAccessPolicyError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_vault_notifications_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupVaultNotificationsOutput,
crate::error::GetBackupVaultNotificationsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetBackupVaultNotificationsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetBackupVaultNotificationsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::GetBackupVaultNotificationsError {
meta: generic,
kind:
crate::error::GetBackupVaultNotificationsErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupVaultNotificationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::GetBackupVaultNotificationsError {
meta: generic,
kind:
crate::error::GetBackupVaultNotificationsErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupVaultNotificationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::GetBackupVaultNotificationsError {
meta: generic,
kind: crate::error::GetBackupVaultNotificationsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupVaultNotificationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::GetBackupVaultNotificationsError {
meta: generic,
kind: crate::error::GetBackupVaultNotificationsErrorKind::ServiceUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetBackupVaultNotificationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::GetBackupVaultNotificationsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_backup_vault_notifications_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetBackupVaultNotificationsOutput,
crate::error::GetBackupVaultNotificationsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_backup_vault_notifications_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_backup_vault_notifications(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetBackupVaultNotificationsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_legal_hold_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetLegalHoldOutput, crate::error::GetLegalHoldError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetLegalHoldError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetLegalHoldError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::GetLegalHoldError {
meta: generic,
kind: crate::error::GetLegalHoldErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::GetLegalHoldError {
meta: generic,
kind: crate::error::GetLegalHoldErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetLegalHoldError {
meta: generic,
kind: crate::error::GetLegalHoldErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::GetLegalHoldError {
meta: generic,
kind: crate::error::GetLegalHoldErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetLegalHoldError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_legal_hold_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetLegalHoldOutput, crate::error::GetLegalHoldError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_legal_hold_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_legal_hold(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetLegalHoldError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_recovery_point_restore_metadata_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetRecoveryPointRestoreMetadataOutput,
crate::error::GetRecoveryPointRestoreMetadataError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetRecoveryPointRestoreMetadataError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetRecoveryPointRestoreMetadataError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::GetRecoveryPointRestoreMetadataError { meta: generic, kind: crate::error::GetRecoveryPointRestoreMetadataErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetRecoveryPointRestoreMetadataError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"MissingParameterValueException" => crate::error::GetRecoveryPointRestoreMetadataError { meta: generic, kind: crate::error::GetRecoveryPointRestoreMetadataErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetRecoveryPointRestoreMetadataError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::GetRecoveryPointRestoreMetadataError { meta: generic, kind: crate::error::GetRecoveryPointRestoreMetadataErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetRecoveryPointRestoreMetadataError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceUnavailableException" => crate::error::GetRecoveryPointRestoreMetadataError { meta: generic, kind: crate::error::GetRecoveryPointRestoreMetadataErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetRecoveryPointRestoreMetadataError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::GetRecoveryPointRestoreMetadataError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_recovery_point_restore_metadata_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetRecoveryPointRestoreMetadataOutput,
crate::error::GetRecoveryPointRestoreMetadataError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::get_recovery_point_restore_metadata_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_get_recovery_point_restore_metadata(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetRecoveryPointRestoreMetadataError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_supported_resource_types_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetSupportedResourceTypesOutput,
crate::error::GetSupportedResourceTypesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetSupportedResourceTypesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetSupportedResourceTypesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ServiceUnavailableException" => crate::error::GetSupportedResourceTypesError {
meta: generic,
kind: crate::error::GetSupportedResourceTypesErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetSupportedResourceTypesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetSupportedResourceTypesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_supported_resource_types_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetSupportedResourceTypesOutput,
crate::error::GetSupportedResourceTypesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_supported_resource_types_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_supported_resource_types(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetSupportedResourceTypesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListBackupJobsOutput, crate::error::ListBackupJobsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListBackupJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListBackupJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListBackupJobsError {
meta: generic,
kind: crate::error::ListBackupJobsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListBackupJobsError {
meta: generic,
kind: crate::error::ListBackupJobsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListBackupJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListBackupJobsOutput, crate::error::ListBackupJobsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_backup_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_backup_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListBackupJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_plans_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListBackupPlansOutput, crate::error::ListBackupPlansError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListBackupPlansError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListBackupPlansError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListBackupPlansError {
meta: generic,
kind: crate::error::ListBackupPlansErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlansError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::ListBackupPlansError {
meta: generic,
kind: crate::error::ListBackupPlansErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlansError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListBackupPlansError {
meta: generic,
kind: crate::error::ListBackupPlansErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlansError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListBackupPlansError {
meta: generic,
kind: crate::error::ListBackupPlansErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlansError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListBackupPlansError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_plans_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListBackupPlansOutput, crate::error::ListBackupPlansError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_backup_plans_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_backup_plans(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListBackupPlansError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_plan_templates_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBackupPlanTemplatesOutput,
crate::error::ListBackupPlanTemplatesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListBackupPlanTemplatesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListBackupPlanTemplatesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListBackupPlanTemplatesError {
meta: generic,
kind: crate::error::ListBackupPlanTemplatesErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlanTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::ListBackupPlanTemplatesError {
meta: generic,
kind: crate::error::ListBackupPlanTemplatesErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlanTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListBackupPlanTemplatesError {
meta: generic,
kind: crate::error::ListBackupPlanTemplatesErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlanTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListBackupPlanTemplatesError {
meta: generic,
kind: crate::error::ListBackupPlanTemplatesErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlanTemplatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListBackupPlanTemplatesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_plan_templates_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBackupPlanTemplatesOutput,
crate::error::ListBackupPlanTemplatesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_backup_plan_templates_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_backup_plan_templates(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListBackupPlanTemplatesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_plan_versions_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBackupPlanVersionsOutput,
crate::error::ListBackupPlanVersionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListBackupPlanVersionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListBackupPlanVersionsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListBackupPlanVersionsError {
meta: generic,
kind: crate::error::ListBackupPlanVersionsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlanVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::ListBackupPlanVersionsError {
meta: generic,
kind: crate::error::ListBackupPlanVersionsErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlanVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListBackupPlanVersionsError {
meta: generic,
kind: crate::error::ListBackupPlanVersionsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlanVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListBackupPlanVersionsError {
meta: generic,
kind: crate::error::ListBackupPlanVersionsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupPlanVersionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListBackupPlanVersionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_plan_versions_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBackupPlanVersionsOutput,
crate::error::ListBackupPlanVersionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_backup_plan_versions_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_backup_plan_versions(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListBackupPlanVersionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_selections_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBackupSelectionsOutput,
crate::error::ListBackupSelectionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListBackupSelectionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListBackupSelectionsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListBackupSelectionsError {
meta: generic,
kind: crate::error::ListBackupSelectionsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupSelectionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::ListBackupSelectionsError {
meta: generic,
kind: crate::error::ListBackupSelectionsErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupSelectionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListBackupSelectionsError {
meta: generic,
kind: crate::error::ListBackupSelectionsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupSelectionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListBackupSelectionsError {
meta: generic,
kind: crate::error::ListBackupSelectionsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupSelectionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListBackupSelectionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_selections_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListBackupSelectionsOutput,
crate::error::ListBackupSelectionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_backup_selections_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_backup_selections(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListBackupSelectionsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_vaults_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListBackupVaultsOutput, crate::error::ListBackupVaultsError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListBackupVaultsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListBackupVaultsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListBackupVaultsError {
meta: generic,
kind: crate::error::ListBackupVaultsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupVaultsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::ListBackupVaultsError {
meta: generic,
kind: crate::error::ListBackupVaultsErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupVaultsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListBackupVaultsError {
meta: generic,
kind: crate::error::ListBackupVaultsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupVaultsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListBackupVaultsError {
meta: generic,
kind: crate::error::ListBackupVaultsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListBackupVaultsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListBackupVaultsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_backup_vaults_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListBackupVaultsOutput, crate::error::ListBackupVaultsError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_backup_vaults_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_backup_vaults(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListBackupVaultsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_copy_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListCopyJobsOutput, crate::error::ListCopyJobsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListCopyJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListCopyJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListCopyJobsError {
meta: generic,
kind: crate::error::ListCopyJobsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListCopyJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListCopyJobsError {
meta: generic,
kind: crate::error::ListCopyJobsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListCopyJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListCopyJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_copy_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListCopyJobsOutput, crate::error::ListCopyJobsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_copy_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_copy_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListCopyJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_frameworks_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListFrameworksOutput, crate::error::ListFrameworksError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListFrameworksError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListFrameworksError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListFrameworksError {
meta: generic,
kind: crate::error::ListFrameworksErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFrameworksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListFrameworksError {
meta: generic,
kind: crate::error::ListFrameworksErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListFrameworksError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListFrameworksError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_frameworks_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListFrameworksOutput, crate::error::ListFrameworksError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_frameworks_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_frameworks(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListFrameworksError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_legal_holds_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListLegalHoldsOutput, crate::error::ListLegalHoldsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListLegalHoldsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListLegalHoldsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListLegalHoldsError {
meta: generic,
kind: crate::error::ListLegalHoldsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListLegalHoldsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListLegalHoldsError {
meta: generic,
kind: crate::error::ListLegalHoldsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListLegalHoldsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListLegalHoldsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_legal_holds_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListLegalHoldsOutput, crate::error::ListLegalHoldsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_legal_holds_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_legal_holds(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListLegalHoldsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_protected_resources_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListProtectedResourcesOutput,
crate::error::ListProtectedResourcesError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListProtectedResourcesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListProtectedResourcesError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListProtectedResourcesError {
meta: generic,
kind: crate::error::ListProtectedResourcesErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListProtectedResourcesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListProtectedResourcesError {
meta: generic,
kind: crate::error::ListProtectedResourcesErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListProtectedResourcesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListProtectedResourcesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_protected_resources_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListProtectedResourcesOutput,
crate::error::ListProtectedResourcesError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_protected_resources_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_protected_resources(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListProtectedResourcesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recovery_points_by_backup_vault_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListRecoveryPointsByBackupVaultOutput,
crate::error::ListRecoveryPointsByBackupVaultError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListRecoveryPointsByBackupVaultError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListRecoveryPointsByBackupVaultError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListRecoveryPointsByBackupVaultError { meta: generic, kind: crate::error::ListRecoveryPointsByBackupVaultErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByBackupVaultError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"MissingParameterValueException" => crate::error::ListRecoveryPointsByBackupVaultError { meta: generic, kind: crate::error::ListRecoveryPointsByBackupVaultErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByBackupVaultError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::ListRecoveryPointsByBackupVaultError { meta: generic, kind: crate::error::ListRecoveryPointsByBackupVaultErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByBackupVaultError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceUnavailableException" => crate::error::ListRecoveryPointsByBackupVaultError { meta: generic, kind: crate::error::ListRecoveryPointsByBackupVaultErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByBackupVaultError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::ListRecoveryPointsByBackupVaultError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recovery_points_by_backup_vault_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListRecoveryPointsByBackupVaultOutput,
crate::error::ListRecoveryPointsByBackupVaultError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::list_recovery_points_by_backup_vault_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_recovery_points_by_backup_vault(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByBackupVaultError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recovery_points_by_legal_hold_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListRecoveryPointsByLegalHoldOutput,
crate::error::ListRecoveryPointsByLegalHoldError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListRecoveryPointsByLegalHoldError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListRecoveryPointsByLegalHoldError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListRecoveryPointsByLegalHoldError {
meta: generic,
kind:
crate::error::ListRecoveryPointsByLegalHoldErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::ListRecoveryPointsByLegalHoldError {
meta: generic,
kind:
crate::error::ListRecoveryPointsByLegalHoldErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ServiceUnavailableException" => crate::error::ListRecoveryPointsByLegalHoldError {
meta: generic,
kind: crate::error::ListRecoveryPointsByLegalHoldErrorKind::ServiceUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByLegalHoldError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::ListRecoveryPointsByLegalHoldError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recovery_points_by_legal_hold_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListRecoveryPointsByLegalHoldOutput,
crate::error::ListRecoveryPointsByLegalHoldError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::list_recovery_points_by_legal_hold_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_list_recovery_points_by_legal_hold(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListRecoveryPointsByLegalHoldError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recovery_points_by_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListRecoveryPointsByResourceOutput,
crate::error::ListRecoveryPointsByResourceError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListRecoveryPointsByResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListRecoveryPointsByResourceError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListRecoveryPointsByResourceError {
meta: generic,
kind:
crate::error::ListRecoveryPointsByResourceErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::ListRecoveryPointsByResourceError {
meta: generic,
kind:
crate::error::ListRecoveryPointsByResourceErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::ListRecoveryPointsByResourceError {
meta: generic,
kind: crate::error::ListRecoveryPointsByResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListRecoveryPointsByResourceError {
meta: generic,
kind: crate::error::ListRecoveryPointsByResourceErrorKind::ServiceUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRecoveryPointsByResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::ListRecoveryPointsByResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_recovery_points_by_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListRecoveryPointsByResourceOutput,
crate::error::ListRecoveryPointsByResourceError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_recovery_points_by_resource_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_list_recovery_points_by_resource(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListRecoveryPointsByResourceError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_report_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListReportJobsOutput, crate::error::ListReportJobsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListReportJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListReportJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListReportJobsError {
meta: generic,
kind: crate::error::ListReportJobsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListReportJobsError {
meta: generic,
kind: crate::error::ListReportJobsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListReportJobsError {
meta: generic,
kind: crate::error::ListReportJobsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReportJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListReportJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_report_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListReportJobsOutput, crate::error::ListReportJobsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_report_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_report_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListReportJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_report_plans_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListReportPlansOutput, crate::error::ListReportPlansError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListReportPlansError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListReportPlansError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListReportPlansError {
meta: generic,
kind: crate::error::ListReportPlansErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReportPlansError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListReportPlansError {
meta: generic,
kind: crate::error::ListReportPlansErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListReportPlansError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListReportPlansError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_report_plans_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListReportPlansOutput, crate::error::ListReportPlansError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_report_plans_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_report_plans(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListReportPlansError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_restore_jobs_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListRestoreJobsOutput, crate::error::ListRestoreJobsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListRestoreJobsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListRestoreJobsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListRestoreJobsError {
meta: generic,
kind: crate::error::ListRestoreJobsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRestoreJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::ListRestoreJobsError {
meta: generic,
kind: crate::error::ListRestoreJobsErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRestoreJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListRestoreJobsError {
meta: generic,
kind: crate::error::ListRestoreJobsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRestoreJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListRestoreJobsError {
meta: generic,
kind: crate::error::ListRestoreJobsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListRestoreJobsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListRestoreJobsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_restore_jobs_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListRestoreJobsOutput, crate::error::ListRestoreJobsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_restore_jobs_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_restore_jobs(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListRestoreJobsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListTagsOutput, crate::error::ListTagsError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListTagsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListTagsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::ListTagsError {
meta: generic,
kind: crate::error::ListTagsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::ListTagsError {
meta: generic,
kind: crate::error::ListTagsErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListTagsError {
meta: generic,
kind: crate::error::ListTagsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::ListTagsError {
meta: generic,
kind: crate::error::ListTagsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListTagsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListTagsOutput, crate::error::ListTagsError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_tags_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_tags(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListTagsError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_backup_vault_access_policy_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::PutBackupVaultAccessPolicyOutput,
crate::error::PutBackupVaultAccessPolicyError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PutBackupVaultAccessPolicyError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::PutBackupVaultAccessPolicyError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::PutBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::PutBackupVaultAccessPolicyErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::PutBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::PutBackupVaultAccessPolicyErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::PutBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::PutBackupVaultAccessPolicyErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::PutBackupVaultAccessPolicyError {
meta: generic,
kind: crate::error::PutBackupVaultAccessPolicyErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultAccessPolicyError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::PutBackupVaultAccessPolicyError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_backup_vault_access_policy_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::PutBackupVaultAccessPolicyOutput,
crate::error::PutBackupVaultAccessPolicyError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::put_backup_vault_access_policy_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_backup_vault_lock_configuration_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::PutBackupVaultLockConfigurationOutput,
crate::error::PutBackupVaultLockConfigurationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PutBackupVaultLockConfigurationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::PutBackupVaultLockConfigurationError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::PutBackupVaultLockConfigurationError { meta: generic, kind: crate::error::PutBackupVaultLockConfigurationErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidRequestException" => crate::error::PutBackupVaultLockConfigurationError { meta: generic, kind: crate::error::PutBackupVaultLockConfigurationErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"MissingParameterValueException" => crate::error::PutBackupVaultLockConfigurationError { meta: generic, kind: crate::error::PutBackupVaultLockConfigurationErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::PutBackupVaultLockConfigurationError { meta: generic, kind: crate::error::PutBackupVaultLockConfigurationErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ServiceUnavailableException" => crate::error::PutBackupVaultLockConfigurationError { meta: generic, kind: crate::error::PutBackupVaultLockConfigurationErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultLockConfigurationError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::PutBackupVaultLockConfigurationError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_backup_vault_lock_configuration_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::PutBackupVaultLockConfigurationOutput,
crate::error::PutBackupVaultLockConfigurationError,
> {
Ok({
#[allow(unused_mut)]
let mut output =
crate::output::put_backup_vault_lock_configuration_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_backup_vault_notifications_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::PutBackupVaultNotificationsOutput,
crate::error::PutBackupVaultNotificationsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PutBackupVaultNotificationsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::PutBackupVaultNotificationsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::PutBackupVaultNotificationsError {
meta: generic,
kind:
crate::error::PutBackupVaultNotificationsErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultNotificationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"MissingParameterValueException" => crate::error::PutBackupVaultNotificationsError {
meta: generic,
kind:
crate::error::PutBackupVaultNotificationsErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultNotificationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::PutBackupVaultNotificationsError {
meta: generic,
kind: crate::error::PutBackupVaultNotificationsErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultNotificationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::PutBackupVaultNotificationsError {
meta: generic,
kind: crate::error::PutBackupVaultNotificationsErrorKind::ServiceUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutBackupVaultNotificationsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::PutBackupVaultNotificationsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_backup_vault_notifications_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::PutBackupVaultNotificationsOutput,
crate::error::PutBackupVaultNotificationsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::put_backup_vault_notifications_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_backup_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartBackupJobOutput, crate::error::StartBackupJobError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartBackupJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartBackupJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::StartBackupJobError {
meta: generic,
kind: crate::error::StartBackupJobErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StartBackupJobError {
meta: generic,
kind: crate::error::StartBackupJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::StartBackupJobError {
meta: generic,
kind: crate::error::StartBackupJobErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::StartBackupJobError {
meta: generic,
kind: crate::error::StartBackupJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartBackupJobError {
meta: generic,
kind: crate::error::StartBackupJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::StartBackupJobError {
meta: generic,
kind: crate::error::StartBackupJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartBackupJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_backup_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartBackupJobOutput, crate::error::StartBackupJobError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_backup_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_backup_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartBackupJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_copy_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartCopyJobOutput, crate::error::StartCopyJobError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartCopyJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartCopyJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::StartCopyJobError {
meta: generic,
kind: crate::error::StartCopyJobErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StartCopyJobError {
meta: generic,
kind: crate::error::StartCopyJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::StartCopyJobError {
meta: generic,
kind: crate::error::StartCopyJobErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::StartCopyJobError {
meta: generic,
kind: crate::error::StartCopyJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartCopyJobError {
meta: generic,
kind: crate::error::StartCopyJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::StartCopyJobError {
meta: generic,
kind: crate::error::StartCopyJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartCopyJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartCopyJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_copy_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartCopyJobOutput, crate::error::StartCopyJobError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_copy_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_copy_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartCopyJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_report_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartReportJobOutput, crate::error::StartReportJobError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartReportJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartReportJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::StartReportJobError {
meta: generic,
kind: crate::error::StartReportJobErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartReportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::StartReportJobError {
meta: generic,
kind: crate::error::StartReportJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartReportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartReportJobError {
meta: generic,
kind: crate::error::StartReportJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartReportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::StartReportJobError {
meta: generic,
kind: crate::error::StartReportJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartReportJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartReportJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_report_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartReportJobOutput, crate::error::StartReportJobError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_report_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_report_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartReportJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_restore_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartRestoreJobOutput, crate::error::StartRestoreJobError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StartRestoreJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StartRestoreJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::StartRestoreJobError {
meta: generic,
kind: crate::error::StartRestoreJobErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::StartRestoreJobError {
meta: generic,
kind: crate::error::StartRestoreJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StartRestoreJobError {
meta: generic,
kind: crate::error::StartRestoreJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::StartRestoreJobError {
meta: generic,
kind: crate::error::StartRestoreJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StartRestoreJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StartRestoreJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_start_restore_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StartRestoreJobOutput, crate::error::StartRestoreJobError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::start_restore_job_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_start_restore_job(
response.body().as_ref(),
output,
)
.map_err(crate::error::StartRestoreJobError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_backup_job_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopBackupJobOutput, crate::error::StopBackupJobError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::StopBackupJobError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::StopBackupJobError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::StopBackupJobError {
meta: generic,
kind: crate::error::StopBackupJobErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::StopBackupJobError {
meta: generic,
kind: crate::error::StopBackupJobErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::StopBackupJobError {
meta: generic,
kind: crate::error::StopBackupJobErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::StopBackupJobError {
meta: generic,
kind: crate::error::StopBackupJobErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::StopBackupJobError {
meta: generic,
kind: crate::error::StopBackupJobErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::StopBackupJobError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::StopBackupJobError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_stop_backup_job_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::StopBackupJobOutput, crate::error::StopBackupJobError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::stop_backup_job_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_tag_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::TagResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::TagResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::TagResourceError {
meta: generic,
kind: crate::error::TagResourceErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::TagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::TagResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_tag_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::TagResourceOutput, crate::error::TagResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::tag_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_untag_resource_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UntagResourceError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UntagResourceError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::UntagResourceError {
meta: generic,
kind: crate::error::UntagResourceErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UntagResourceError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UntagResourceError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_untag_resource_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UntagResourceOutput, crate::error::UntagResourceError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::untag_resource_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_backup_plan_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateBackupPlanOutput, crate::error::UpdateBackupPlanError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateBackupPlanError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateBackupPlanError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::UpdateBackupPlanError {
meta: generic,
kind: crate::error::UpdateBackupPlanErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::UpdateBackupPlanError {
meta: generic,
kind: crate::error::UpdateBackupPlanErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateBackupPlanError {
meta: generic,
kind: crate::error::UpdateBackupPlanErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::UpdateBackupPlanError {
meta: generic,
kind: crate::error::UpdateBackupPlanErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateBackupPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateBackupPlanError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_backup_plan_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateBackupPlanOutput, crate::error::UpdateBackupPlanError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_backup_plan_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_backup_plan(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateBackupPlanError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_framework_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateFrameworkOutput, crate::error::UpdateFrameworkError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateFrameworkError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateFrameworkError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AlreadyExistsException" => crate::error::UpdateFrameworkError {
meta: generic,
kind: crate::error::UpdateFrameworkErrorKind::AlreadyExistsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::already_exists_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_already_exists_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::UpdateFrameworkError {
meta: generic,
kind: crate::error::UpdateFrameworkErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterValueException" => crate::error::UpdateFrameworkError {
meta: generic,
kind: crate::error::UpdateFrameworkErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UpdateFrameworkError {
meta: generic,
kind: crate::error::UpdateFrameworkErrorKind::LimitExceededException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::limit_exceeded_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_limit_exceeded_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::UpdateFrameworkError {
meta: generic,
kind: crate::error::UpdateFrameworkErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateFrameworkError {
meta: generic,
kind: crate::error::UpdateFrameworkErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::UpdateFrameworkError {
meta: generic,
kind: crate::error::UpdateFrameworkErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateFrameworkError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateFrameworkError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_framework_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateFrameworkOutput, crate::error::UpdateFrameworkError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_framework_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_framework(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateFrameworkError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_global_settings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateGlobalSettingsOutput,
crate::error::UpdateGlobalSettingsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateGlobalSettingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateGlobalSettingsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::UpdateGlobalSettingsError {
meta: generic,
kind: crate::error::UpdateGlobalSettingsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateGlobalSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidRequestException" => crate::error::UpdateGlobalSettingsError {
meta: generic,
kind: crate::error::UpdateGlobalSettingsErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateGlobalSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::UpdateGlobalSettingsError {
meta: generic,
kind: crate::error::UpdateGlobalSettingsErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateGlobalSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::UpdateGlobalSettingsError {
meta: generic,
kind: crate::error::UpdateGlobalSettingsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateGlobalSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateGlobalSettingsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_global_settings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateGlobalSettingsOutput,
crate::error::UpdateGlobalSettingsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_global_settings_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_recovery_point_lifecycle_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateRecoveryPointLifecycleOutput,
crate::error::UpdateRecoveryPointLifecycleError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateRecoveryPointLifecycleError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateRecoveryPointLifecycleError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::UpdateRecoveryPointLifecycleError {
meta: generic,
kind:
crate::error::UpdateRecoveryPointLifecycleErrorKind::InvalidParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRecoveryPointLifecycleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"InvalidRequestException" => crate::error::UpdateRecoveryPointLifecycleError {
meta: generic,
kind: crate::error::UpdateRecoveryPointLifecycleErrorKind::InvalidRequestException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_request_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_request_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRecoveryPointLifecycleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::UpdateRecoveryPointLifecycleError {
meta: generic,
kind:
crate::error::UpdateRecoveryPointLifecycleErrorKind::MissingParameterValueException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRecoveryPointLifecycleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"ResourceNotFoundException" => crate::error::UpdateRecoveryPointLifecycleError {
meta: generic,
kind: crate::error::UpdateRecoveryPointLifecycleErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRecoveryPointLifecycleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::UpdateRecoveryPointLifecycleError {
meta: generic,
kind: crate::error::UpdateRecoveryPointLifecycleErrorKind::ServiceUnavailableException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRecoveryPointLifecycleError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
_ => crate::error::UpdateRecoveryPointLifecycleError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_recovery_point_lifecycle_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateRecoveryPointLifecycleOutput,
crate::error::UpdateRecoveryPointLifecycleError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_recovery_point_lifecycle_output::Builder::default();
let _ = response;
output =
crate::json_deser::deser_operation_crate_operation_update_recovery_point_lifecycle(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateRecoveryPointLifecycleError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_region_settings_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateRegionSettingsOutput,
crate::error::UpdateRegionSettingsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateRegionSettingsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateRegionSettingsError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidParameterValueException" => crate::error::UpdateRegionSettingsError {
meta: generic,
kind: crate::error::UpdateRegionSettingsErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRegionSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::UpdateRegionSettingsError {
meta: generic,
kind: crate::error::UpdateRegionSettingsErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRegionSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::UpdateRegionSettingsError {
meta: generic,
kind: crate::error::UpdateRegionSettingsErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateRegionSettingsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateRegionSettingsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_region_settings_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateRegionSettingsOutput,
crate::error::UpdateRegionSettingsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_region_settings_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_report_plan_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateReportPlanOutput, crate::error::UpdateReportPlanError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateReportPlanError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::UpdateReportPlanError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"ConflictException" => {
crate::error::UpdateReportPlanError {
meta: generic,
kind: crate::error::UpdateReportPlanErrorKind::ConflictException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::conflict_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_conflict_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidParameterValueException" => crate::error::UpdateReportPlanError {
meta: generic,
kind: crate::error::UpdateReportPlanErrorKind::InvalidParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::invalid_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"MissingParameterValueException" => crate::error::UpdateReportPlanError {
meta: generic,
kind: crate::error::UpdateReportPlanErrorKind::MissingParameterValueException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::missing_parameter_value_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_missing_parameter_value_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateReportPlanError {
meta: generic,
kind: crate::error::UpdateReportPlanErrorKind::ResourceNotFoundException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_not_found_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_not_found_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ServiceUnavailableException" => crate::error::UpdateReportPlanError {
meta: generic,
kind: crate::error::UpdateReportPlanErrorKind::ServiceUnavailableException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::service_unavailable_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_service_unavailable_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateReportPlanError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateReportPlanError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_report_plan_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::UpdateReportPlanOutput, crate::error::UpdateReportPlanError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_report_plan_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_update_report_plan(
response.body().as_ref(),
output,
)
.map_err(crate::error::UpdateReportPlanError::unhandled)?;
output.build()
})
}