#[allow(clippy::unnecessary_wraps)]
pub fn parse_add_tags_to_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AddTagsToCertificateOutput,
crate::error::AddTagsToCertificateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::AddTagsToCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::AddTagsToCertificateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::AddTagsToCertificateError {
meta: generic,
kind: crate::error::AddTagsToCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::AddTagsToCertificateError {
meta: generic,
kind: crate::error::AddTagsToCertificateErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidTagException" => crate::error::AddTagsToCertificateError {
meta: generic,
kind: crate::error::AddTagsToCertificateErrorKind::InvalidTagException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_tag_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::AddTagsToCertificateError {
meta: generic,
kind: crate::error::AddTagsToCertificateErrorKind::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::AddTagsToCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TagPolicyException" => crate::error::AddTagsToCertificateError {
meta: generic,
kind: crate::error::AddTagsToCertificateErrorKind::TagPolicyException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::tag_policy_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_tag_policy_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ThrottlingException" => crate::error::AddTagsToCertificateError {
meta: generic,
kind: crate::error::AddTagsToCertificateErrorKind::ThrottlingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::throttling_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_throttling_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::AddTagsToCertificateError {
meta: generic,
kind: crate::error::AddTagsToCertificateErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::AddTagsToCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::AddTagsToCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_add_tags_to_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::AddTagsToCertificateOutput,
crate::error::AddTagsToCertificateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::add_tags_to_certificate_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteCertificateOutput, crate::error::DeleteCertificateError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DeleteCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DeleteCertificateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::DeleteCertificateError {
meta: generic,
kind: crate::error::DeleteCertificateErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::DeleteCertificateError {
meta: generic,
kind: crate::error::DeleteCertificateErrorKind::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::DeleteCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"InvalidArnException" => crate::error::DeleteCertificateError {
meta: generic,
kind: crate::error::DeleteCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceInUseException" => crate::error::DeleteCertificateError {
meta: generic,
kind: crate::error::DeleteCertificateErrorKind::ResourceInUseException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::resource_in_use_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_resource_in_use_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DeleteCertificateError {
meta: generic,
kind: crate::error::DeleteCertificateErrorKind::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::DeleteCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ThrottlingException" => crate::error::DeleteCertificateError {
meta: generic,
kind: crate::error::DeleteCertificateErrorKind::ThrottlingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::throttling_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_throttling_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DeleteCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DeleteCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_delete_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::DeleteCertificateOutput, crate::error::DeleteCertificateError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::delete_certificate_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeCertificateOutput,
crate::error::DescribeCertificateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::DescribeCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::DescribeCertificateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::DescribeCertificateError {
meta: generic,
kind: crate::error::DescribeCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::DescribeCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::DescribeCertificateError {
meta: generic,
kind: crate::error::DescribeCertificateErrorKind::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::DescribeCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::DescribeCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_describe_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::DescribeCertificateOutput,
crate::error::DescribeCertificateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::describe_certificate_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_describe_certificate(
response.body().as_ref(),
output,
)
.map_err(crate::error::DescribeCertificateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ExportCertificateOutput, crate::error::ExportCertificateError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ExportCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ExportCertificateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::ExportCertificateError {
meta: generic,
kind: crate::error::ExportCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RequestInProgressException" => crate::error::ExportCertificateError {
meta: generic,
kind: crate::error::ExportCertificateErrorKind::RequestInProgressException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::request_in_progress_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_request_in_progress_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ExportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ExportCertificateError {
meta: generic,
kind: crate::error::ExportCertificateErrorKind::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::ExportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ExportCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_export_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ExportCertificateOutput, crate::error::ExportCertificateError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::export_certificate_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_export_certificate(
response.body().as_ref(),
output,
)
.map_err(crate::error::ExportCertificateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_account_configuration_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetAccountConfigurationOutput,
crate::error::GetAccountConfigurationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetAccountConfigurationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::GetAccountConfigurationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::GetAccountConfigurationError {
meta: generic,
kind: crate::error::GetAccountConfigurationErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAccountConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ThrottlingException" => crate::error::GetAccountConfigurationError {
meta: generic,
kind: crate::error::GetAccountConfigurationErrorKind::ThrottlingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::throttling_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_throttling_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetAccountConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetAccountConfigurationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_account_configuration_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::GetAccountConfigurationOutput,
crate::error::GetAccountConfigurationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_account_configuration_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_account_configuration(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetAccountConfigurationError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetCertificateOutput, crate::error::GetCertificateError> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::GetCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::GetCertificateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::GetCertificateError {
meta: generic,
kind: crate::error::GetCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"RequestInProgressException" => crate::error::GetCertificateError {
meta: generic,
kind: crate::error::GetCertificateErrorKind::RequestInProgressException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output =
crate::error::request_in_progress_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_request_in_progress_exception_json_err(response.body().as_ref(), output).map_err(crate::error::GetCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::GetCertificateError {
meta: generic,
kind: crate::error::GetCertificateErrorKind::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::GetCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::GetCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_get_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::GetCertificateOutput, crate::error::GetCertificateError> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::get_certificate_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_get_certificate(
response.body().as_ref(),
output,
)
.map_err(crate::error::GetCertificateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportCertificateOutput, crate::error::ImportCertificateError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ImportCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ImportCertificateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::ImportCertificateError {
meta: generic,
kind: crate::error::ImportCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ImportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::ImportCertificateError {
meta: generic,
kind: crate::error::ImportCertificateErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ImportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidTagException" => crate::error::ImportCertificateError {
meta: generic,
kind: crate::error::ImportCertificateErrorKind::InvalidTagException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_tag_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ImportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::ImportCertificateError {
meta: generic,
kind: crate::error::ImportCertificateErrorKind::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::ImportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ImportCertificateError {
meta: generic,
kind: crate::error::ImportCertificateErrorKind::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::ImportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TagPolicyException" => crate::error::ImportCertificateError {
meta: generic,
kind: crate::error::ImportCertificateErrorKind::TagPolicyException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::tag_policy_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_tag_policy_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ImportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::ImportCertificateError {
meta: generic,
kind: crate::error::ImportCertificateErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ImportCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ImportCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_import_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ImportCertificateOutput, crate::error::ImportCertificateError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::import_certificate_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_import_certificate(
response.body().as_ref(),
output,
)
.map_err(crate::error::ImportCertificateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_certificates_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListCertificatesOutput, crate::error::ListCertificatesError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListCertificatesError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ListCertificatesError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArgsException" => crate::error::ListCertificatesError {
meta: generic,
kind: crate::error::ListCertificatesErrorKind::InvalidArgsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_args_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_args_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListCertificatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::ListCertificatesError {
meta: generic,
kind: crate::error::ListCertificatesErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListCertificatesError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListCertificatesError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_certificates_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::ListCertificatesOutput, crate::error::ListCertificatesError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_certificates_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_certificates(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListCertificatesError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_for_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTagsForCertificateOutput,
crate::error::ListTagsForCertificateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ListTagsForCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::ListTagsForCertificateError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::ListTagsForCertificateError {
meta: generic,
kind: crate::error::ListTagsForCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ListTagsForCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::ListTagsForCertificateError {
meta: generic,
kind: crate::error::ListTagsForCertificateErrorKind::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::ListTagsForCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::ListTagsForCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_list_tags_for_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ListTagsForCertificateOutput,
crate::error::ListTagsForCertificateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::list_tags_for_certificate_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_list_tags_for_certificate(
response.body().as_ref(),
output,
)
.map_err(crate::error::ListTagsForCertificateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_account_configuration_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::PutAccountConfigurationOutput,
crate::error::PutAccountConfigurationError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::PutAccountConfigurationError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::PutAccountConfigurationError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"AccessDeniedException" => crate::error::PutAccountConfigurationError {
meta: generic,
kind: crate::error::PutAccountConfigurationErrorKind::AccessDeniedException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::access_denied_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_access_denied_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutAccountConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ConflictException" => {
crate::error::PutAccountConfigurationError {
meta: generic,
kind: crate::error::PutAccountConfigurationErrorKind::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::PutAccountConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
}
}
"ThrottlingException" => crate::error::PutAccountConfigurationError {
meta: generic,
kind: crate::error::PutAccountConfigurationErrorKind::ThrottlingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::throttling_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_throttling_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutAccountConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ValidationException" => crate::error::PutAccountConfigurationError {
meta: generic,
kind: crate::error::PutAccountConfigurationErrorKind::ValidationException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::validation_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_validation_exception_json_err(response.body().as_ref(), output).map_err(crate::error::PutAccountConfigurationError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::PutAccountConfigurationError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_put_account_configuration_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::PutAccountConfigurationOutput,
crate::error::PutAccountConfigurationError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::put_account_configuration_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_remove_tags_from_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RemoveTagsFromCertificateOutput,
crate::error::RemoveTagsFromCertificateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RemoveTagsFromCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::RemoveTagsFromCertificateError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::RemoveTagsFromCertificateError {
meta: generic,
kind: crate::error::RemoveTagsFromCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidParameterException" => crate::error::RemoveTagsFromCertificateError {
meta: generic,
kind: crate::error::RemoveTagsFromCertificateErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidTagException" => crate::error::RemoveTagsFromCertificateError {
meta: generic,
kind: crate::error::RemoveTagsFromCertificateErrorKind::InvalidTagException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_tag_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::RemoveTagsFromCertificateError {
meta: generic,
kind: crate::error::RemoveTagsFromCertificateErrorKind::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::RemoveTagsFromCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TagPolicyException" => crate::error::RemoveTagsFromCertificateError {
meta: generic,
kind: crate::error::RemoveTagsFromCertificateErrorKind::TagPolicyException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::tag_policy_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_tag_policy_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ThrottlingException" => crate::error::RemoveTagsFromCertificateError {
meta: generic,
kind: crate::error::RemoveTagsFromCertificateErrorKind::ThrottlingException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::throttling_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_throttling_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RemoveTagsFromCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RemoveTagsFromCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_remove_tags_from_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RemoveTagsFromCertificateOutput,
crate::error::RemoveTagsFromCertificateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::remove_tags_from_certificate_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_renew_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RenewCertificateOutput, crate::error::RenewCertificateError>
{
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RenewCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::RenewCertificateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::RenewCertificateError {
meta: generic,
kind: crate::error::RenewCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RenewCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::RenewCertificateError {
meta: generic,
kind: crate::error::RenewCertificateErrorKind::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::RenewCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RenewCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_renew_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<crate::output::RenewCertificateOutput, crate::error::RenewCertificateError>
{
Ok({
#[allow(unused_mut)]
let mut output = crate::output::renew_certificate_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_request_certificate_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RequestCertificateOutput,
crate::error::RequestCertificateError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::RequestCertificateError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::RequestCertificateError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::RequestCertificateError {
meta: generic,
kind: crate::error::RequestCertificateErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RequestCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidDomainValidationOptionsException" => crate::error::RequestCertificateError {
meta: generic,
kind:
crate::error::RequestCertificateErrorKind::InvalidDomainValidationOptionsException(
{
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_domain_validation_options_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_domain_validation_options_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RequestCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
},
),
},
"InvalidParameterException" => crate::error::RequestCertificateError {
meta: generic,
kind: crate::error::RequestCertificateErrorKind::InvalidParameterException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_parameter_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_parameter_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RequestCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidTagException" => crate::error::RequestCertificateError {
meta: generic,
kind: crate::error::RequestCertificateErrorKind::InvalidTagException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_tag_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_tag_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RequestCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::RequestCertificateError {
meta: generic,
kind: crate::error::RequestCertificateErrorKind::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::RequestCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TagPolicyException" => crate::error::RequestCertificateError {
meta: generic,
kind: crate::error::RequestCertificateErrorKind::TagPolicyException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::tag_policy_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_tag_policy_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RequestCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"TooManyTagsException" => crate::error::RequestCertificateError {
meta: generic,
kind: crate::error::RequestCertificateErrorKind::TooManyTagsException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::too_many_tags_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_too_many_tags_exception_json_err(response.body().as_ref(), output).map_err(crate::error::RequestCertificateError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::RequestCertificateError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_request_certificate_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::RequestCertificateOutput,
crate::error::RequestCertificateError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::request_certificate_output::Builder::default();
let _ = response;
output = crate::json_deser::deser_operation_crate_operation_request_certificate(
response.body().as_ref(),
output,
)
.map_err(crate::error::RequestCertificateError::unhandled)?;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_resend_validation_email_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ResendValidationEmailOutput,
crate::error::ResendValidationEmailError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::ResendValidationEmailError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => return Err(crate::error::ResendValidationEmailError::unhandled(generic)),
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::ResendValidationEmailError { meta: generic, kind: crate::error::ResendValidationEmailErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ResendValidationEmailError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidDomainValidationOptionsException" => crate::error::ResendValidationEmailError { meta: generic, kind: crate::error::ResendValidationEmailErrorKind::InvalidDomainValidationOptionsException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_domain_validation_options_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_domain_validation_options_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ResendValidationEmailError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"InvalidStateException" => crate::error::ResendValidationEmailError { meta: generic, kind: crate::error::ResendValidationEmailErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp =
{
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::ResendValidationEmailError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
"ResourceNotFoundException" => crate::error::ResendValidationEmailError { meta: generic, kind: crate::error::ResendValidationEmailErrorKind::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::ResendValidationEmailError::unhandled)?;
output.build()
}
;
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
})},
_ => crate::error::ResendValidationEmailError::generic(generic)
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_resend_validation_email_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::ResendValidationEmailOutput,
crate::error::ResendValidationEmailError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::resend_validation_email_output::Builder::default();
let _ = response;
output.build()
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_certificate_options_error(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateCertificateOptionsOutput,
crate::error::UpdateCertificateOptionsError,
> {
let generic = crate::json_deser::parse_http_generic_error(response)
.map_err(crate::error::UpdateCertificateOptionsError::unhandled)?;
let error_code = match generic.code() {
Some(code) => code,
None => {
return Err(crate::error::UpdateCertificateOptionsError::unhandled(
generic,
))
}
};
let _error_message = generic.message().map(|msg| msg.to_owned());
Err(match error_code {
"InvalidArnException" => crate::error::UpdateCertificateOptionsError {
meta: generic,
kind: crate::error::UpdateCertificateOptionsErrorKind::InvalidArnException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_arn_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_arn_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateCertificateOptionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"InvalidStateException" => crate::error::UpdateCertificateOptionsError {
meta: generic,
kind: crate::error::UpdateCertificateOptionsErrorKind::InvalidStateException({
#[allow(unused_mut)]
let mut tmp = {
#[allow(unused_mut)]
let mut output = crate::error::invalid_state_exception::Builder::default();
let _ = response;
output = crate::json_deser::deser_structure_crate_error_invalid_state_exception_json_err(response.body().as_ref(), output).map_err(crate::error::UpdateCertificateOptionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"LimitExceededException" => crate::error::UpdateCertificateOptionsError {
meta: generic,
kind: crate::error::UpdateCertificateOptionsErrorKind::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::UpdateCertificateOptionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
"ResourceNotFoundException" => crate::error::UpdateCertificateOptionsError {
meta: generic,
kind: crate::error::UpdateCertificateOptionsErrorKind::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::UpdateCertificateOptionsError::unhandled)?;
output.build()
};
if tmp.message.is_none() {
tmp.message = _error_message;
}
tmp
}),
},
_ => crate::error::UpdateCertificateOptionsError::generic(generic),
})
}
#[allow(clippy::unnecessary_wraps)]
pub fn parse_update_certificate_options_response(
response: &http::Response<bytes::Bytes>,
) -> std::result::Result<
crate::output::UpdateCertificateOptionsOutput,
crate::error::UpdateCertificateOptionsError,
> {
Ok({
#[allow(unused_mut)]
let mut output = crate::output::update_certificate_options_output::Builder::default();
let _ = response;
output.build()
})
}